gcsdk 1.0.7 → 1.0.9

package/native/src/lib.rs

@@ -5,9 +5,8 @@ use chrono::{DateTime, Utc};
 use neon::types::extract::Json;
 use once_cell::sync::Lazy;
 use serde::{Deserialize, Serialize};
-use sha2::{Digest, Sha256};
-use std::collections::HashMap;
 use std::sync::Mutex;
+use std::time::{SystemTime, UNIX_EPOCH};
 #[derive(Serialize, Deserialize, Clone)]
 struct ChatNode {
     id: String,
@@ -15,15 +14,26 @@ struct ChatNode {
     role: String,
     content: String,
     timestamp: i64,
-    vfs_snapshot: HashMap<String, String>, // Filepath -> Content
+    vfs_snapshot: std::collections::HashMap<String, String>, // Filepath -> Content
+}
+
+#[derive(Serialize, Deserialize)]
+struct TreeNode {
+    id: String,
+    parent_id: Option<String>,
+    role: String,
+    content: String,
+    timestamp: i64,
+    branches: Vec<String>,
+    children: Vec<TreeNode>,
 }
 
 #[derive(Default)]
 struct ConversationRepo {
     // Every commit in the tree indexed by its id
-    nodes: HashMap<String, ChatNode>,
+    nodes: std::collections::HashMap<String, ChatNode>,
     //ponters to the latest node for a given name
-    branches: HashMap<String, String>,
+    branches: std::collections::HashMap<String, String>,
 }
 
 static REPO: Lazy<Mutex<ConversationRepo>> = Lazy::new(|| Mutex::new(ConversationRepo::default()));
@@ -42,18 +52,37 @@ fn commit(
     role: String,
     content: String,
     branch_name: String,
-    Json(vfs_snapshot): Json<HashMap<String, String>>,
+    Json(vfs_snapshot): Json<std::collections::HashMap<String, String>>,
 ) -> Result<String, neon::types::extract::Error> {
-    let mut hasher = Sha256::new();
-    hasher.update(&content);
-    let id = format!("{:x}", hasher.finalize());
+    // Important: commit IDs must be unique for a git-like DAG.
+    // Hashing only `content` causes collisions (e.g. repeated greetings),
+    // which can overwrite nodes and even create parent cycles -> infinite loops / hangs.
+    let timestamp_ms = Utc::now().timestamp_millis();
+    let nonce_ns: u128 = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos();
+
+    let mut hasher = <sha2::Sha256 as sha2::Digest>::new();
+    sha2::Digest::update(&mut hasher, role.as_bytes());
+    sha2::Digest::update(&mut hasher, b"\0");
+    if let Some(pid) = &parent_id {
+        sha2::Digest::update(&mut hasher, pid.as_bytes());
+    }
+    sha2::Digest::update(&mut hasher, b"\0");
+    sha2::Digest::update(&mut hasher, content.as_bytes());
+    sha2::Digest::update(&mut hasher, b"\0");
+    sha2::Digest::update(&mut hasher, timestamp_ms.to_string().as_bytes());
+    sha2::Digest::update(&mut hasher, b"\0");
+    sha2::Digest::update(&mut hasher, nonce_ns.to_string().as_bytes());
+    let id = format!("{:x}", sha2::Digest::finalize(hasher));
 
     let node = ChatNode {
         id: id.clone(),
         parent_id: parent_id.clone(),
         role: role.clone(),
         content: content.clone(),
-        timestamp: Utc::now().timestamp_millis(),
+        timestamp: timestamp_ms,
         vfs_snapshot: vfs_snapshot.clone(),
     };
 
@@ -85,10 +114,19 @@ fn get_history(branch_name: String) -> Result<Json<Vec<ChatNode>>, neon::types::
 
     let mut nodes = Vec::new();
     let mut current_id = repo.branches.get(&branch_name).cloned();
+    let mut visited: std::collections::HashSet<String> = std::collections::HashSet::new();
 
     while let Some(id) = current_id {
+        // Cycle guard: corrupted graphs (e.g. from past ID collisions) must not hang.
+        if !visited.insert(id.clone()) {
+            break;
+        }
         if let Some(node) = repo.nodes.get(&id) {
             nodes.push(node.clone());
+            // Additional guard against self-parent links.
+            if node.parent_id.as_deref() == Some(id.as_str()) {
+                break;
+            }
             current_id = node.parent_id.clone();
         } else {
             break;
@@ -115,12 +153,176 @@ fn checkout(branch_name: String) -> Result<Option<String>, neon::types::extract:
     Ok(repo.branches.get(&branch_name).cloned())
 }
 
+#[neon::export]
+fn create_branch_from_commit(
+    branch_name: String,
+    commit_id: String,
+) -> Result<bool, neon::types::extract::Error> {
+    let mut repo = REPO.lock().unwrap();
+
+    // Verify the commit exists
+    if !repo.nodes.contains_key(&commit_id) {
+        return Ok(false);
+    }
+
+    repo.branches.insert(branch_name, commit_id);
+    Ok(true)
+}
+
+#[neon::export]
+fn get_history_to_commit(commit_id: String) -> Result<Json<Vec<ChatNode>>, neon::types::extract::Error> {
+    let repo = REPO.lock().unwrap();
+
+    let mut nodes = Vec::new();
+    let mut current_id = Some(commit_id);
+    let mut visited: std::collections::HashSet<String> = std::collections::HashSet::new();
+
+    while let Some(id) = current_id {
+        // Cycle guard
+        if !visited.insert(id.clone()) {
+            break;
+        }
+        if let Some(node) = repo.nodes.get(&id) {
+            nodes.push(node.clone());
+            if node.parent_id.as_deref() == Some(id.as_str()) {
+                break;
+            }
+            current_id = node.parent_id.clone();
+        } else {
+            break;
+        }
+    }
+
+    nodes.reverse(); // Return oldest-first
+    Ok(Json(nodes))
+}
+
+#[neon::export]
+fn return_tree_as_json() -> Result<String, neon::types::extract::Error> {
+    let repo = REPO.lock().unwrap();
+
+    if repo.nodes.is_empty() {
+        return Ok("[]".to_string());
+    }
+
+    // Build children map: parent_id -> [child_ids]
+    let mut children_map: std::collections::HashMap<String, Vec<String>> =
+        std::collections::HashMap::new();
+    for node in repo.nodes.values() {
+        if let Some(pid) = &node.parent_id {
+            children_map
+                .entry(pid.clone())
+                .or_default()
+                .push(node.id.clone());
+        }
+    }
+
+    // Build branch lookup: node_id -> [branch_names]
+    let branches: std::collections::HashMap<&String, Vec<&String>> =
+        repo.branches
+            .iter()
+            .fold(std::collections::HashMap::new(), |mut acc, (name, id)| {
+                acc.entry(id).or_default().push(name);
+                acc
+            });
+
+    // Find root nodes (no parent)
+    let mut roots: Vec<_> = repo
+        .nodes
+        .values()
+        .filter(|n| n.parent_id.is_none())
+        .collect();
+    roots.sort_by(|a, b| a.timestamp.cmp(&b.timestamp));
+
+    // Build JSON tree structure
+    let json_trees: Vec<TreeNode> = roots
+        .iter()
+        .map(|root| {
+            let mut visited = std::collections::HashSet::<String>::new();
+            build_json_tree(&root.id, &repo.nodes, &children_map, &branches, &mut visited)
+        })
+        .collect();
+
+    // Serialize to JSON string without pretty formatting
+    let json_string = serde_json::to_string(&json_trees)?;
+    Ok(json_string)
+}
+
+fn build_json_tree(
+    node_id: &str,
+    nodes: &std::collections::HashMap<String, ChatNode>,
+    children_map: &std::collections::HashMap<String, Vec<String>>,
+    branches: &std::collections::HashMap<&String, Vec<&String>>,
+    visited: &mut std::collections::HashSet<String>,
+) -> TreeNode {
+    // Cycle guard: if we ever see the same node twice in the recursion, stop.
+    if !visited.insert(node_id.to_string()) {
+        let node = &nodes[node_id];
+        let branch_names: Vec<String> = branches
+            .get(&node.id)
+            .map(|b| b.iter().map(|s| (*s).clone()).collect())
+            .unwrap_or_default();
+
+        return TreeNode {
+            id: node.id.clone(),
+            parent_id: node.parent_id.clone(),
+            role: node.role.clone(),
+            content: node.content.clone(),
+            timestamp: node.timestamp,
+            branches: branch_names,
+            children: Vec::new(),
+        };
+    }
+
+    let node = &nodes[node_id];
+
+    // Get branch names for this node
+    let branch_names: Vec<String> = branches
+        .get(&node.id)
+        .map(|b| b.iter().map(|s| (*s).clone()).collect())
+        .unwrap_or_default();
+
+    // Build children recursively
+    let mut children: Vec<TreeNode> = Vec::new();
+    if let Some(child_ids) = children_map.get(node_id) {
+        let mut sorted_children: Vec<_> = child_ids.iter().collect();
+        sorted_children.sort_by(|a, b| {
+            let ta = nodes.get(*a).map(|n| n.timestamp).unwrap_or(0);
+            let tb = nodes.get(*b).map(|n| n.timestamp).unwrap_or(0);
+            ta.cmp(&tb)
+        });
+
+        for child_id in sorted_children {
+            children.push(build_json_tree(child_id, nodes, children_map, branches, visited));
+        }
+    }
+
+    TreeNode {
+        id: node.id.clone(),
+        parent_id: node.parent_id.clone(),
+        role: node.role.clone(),
+        content: node.content.clone(),
+        timestamp: node.timestamp,
+        branches: branch_names,
+        children,
+    }
+}
+
 fn build_tree(
     node_id: &str,
-    nodes: &HashMap<String, ChatNode>,
-    children_map: &HashMap<String, Vec<String>>,
-    branches: &HashMap<&String, Vec<&String>>,
+    nodes: &std::collections::HashMap<String, ChatNode>,
+    children_map: &std::collections::HashMap<String, Vec<String>>,
+    branches: &std::collections::HashMap<&String, Vec<&String>>,
+    visited: &mut std::collections::HashSet<String>,
 ) -> termtree::Tree<String> {
+    // Cycle guard (rendering should never hang)
+    if !visited.insert(node_id.to_string()) {
+        return termtree::Tree::new(format!(
+            "\x1b[31m{} (cycle detected)\x1b[0m",
+            &node_id[..7.min(node_id.len())]
+        ));
+    }
+
     let node = &nodes[node_id];
     let short_id = &node.id[..7.min(node.id.len())];
 
@@ -163,7 +365,7 @@ fn build_tree(
         });
 
         for child_id in sorted_children {
-            tree.push(build_tree(child_id, nodes, children_map, branches));
+            tree.push(build_tree(child_id, nodes, children_map, branches, visited));
         }
     }
 
@@ -179,7 +381,8 @@ fn render_tree() -> Result<String, neon::types::extract::Error> {
     }
 
     // Build children map: parent_id -> [child_ids]
-    let mut children_map: HashMap<String, Vec<String>> = HashMap::new();
+    let mut children_map: std::collections::HashMap<String, Vec<String>> =
+        std::collections::HashMap::new();
     for node in repo.nodes.values() {
         if let Some(pid) = &node.parent_id {
             children_map
@@ -190,10 +393,10 @@ fn render_tree() -> Result<String, neon::types::extract::Error> {
     }
 
     // Build branch lookup: node_id -> [branch_names]
-    let branches: HashMap<&String, Vec<&String>> =
+    let branches: std::collections::HashMap<&String, Vec<&String>> =
         repo.branches
             .iter()
-            .fold(HashMap::new(), |mut acc, (name, id)| {
+            .fold(std::collections::HashMap::new(), |mut acc, (name, id)| {
                 acc.entry(id).or_default().push(name);
                 acc
             });
@@ -210,7 +413,8 @@ fn render_tree() -> Result<String, neon::types::extract::Error> {
     let output: String = roots
         .iter()
         .map(|root| {
-            let tree = build_tree(&root.id, &repo.nodes, &children_map, &branches);
+            let mut visited = std::collections::HashSet::<String>::new();
+            let tree = build_tree(&root.id, &repo.nodes, &children_map, &branches, &mut visited);
             tree.to_string()
         })
         .collect::<Vec<_>>()

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "gcsdk",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Git Chat SDK - A Git-like conversation SDK for managing chat histories with branching support",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -10,6 +11,11 @@
       "require": "./dist/index.js",
       "import": "./dist/index.js"
     },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "require": "./dist/types.js",
+      "import": "./dist/types.js"
+    },
     "./react": {
       "types": "./dist/react/ConversationGraph.d.ts",
       "require": "./dist/react/ConversationGraph.js",
@@ -58,20 +64,14 @@
     "@types/bun": "^1.3.5",
     "@types/node": "^20.0.0",
     "@types/react": "^18.0.0",
-    "react": "^18.0.0 || ^19.0.0",
-    "reactflow": "^11.11.4",
     "typescript": "^5.0.0"
   },
   "peerDependencies": {
-    "react": "^18.0.0 || ^19.0.0",
-    "reactflow": "^11.0.0"
+    "react": "^18.0.0 || ^19.0.0"
   },
   "peerDependenciesMeta": {
     "react": {
       "optional": true
-    },
-    "reactflow": {
-      "optional": true
     }
   },
   "engines": {