feat: add DAG branching, prefix lookup, and LangGraph import/export

- engine.Branch() creates child nodes from any existing node (DAG branching)
- storage.FindByPrefix() for short-prefix node lookup (UX improvement)
- ImportLangGraph/ExportForLangGraph for cross-tool conversation migration

Author: Patel230

engine/branch.go

@@ -0,0 +1,69 @@
+package engine
+
+import (
+	"context"
+	"crypto/sha256"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/GrayCodeAI/yaad/storage"
+)
+
+// Branch creates a new node branching off from the given nodeID.
+// The new node inherits the parent's project and scope but carries the
+// provided newContent and newType. An edge of type "caused_by" links the
+// branch node back to its parent, forming a DAG branch.
+func (e *Engine) Branch(ctx context.Context, nodeID, newContent, newType string) (*storage.Node, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	if newContent == "" {
+		return nil, fmt.Errorf("branch content cannot be empty")
+	}
+	if newType != "" && !validNodeTypes[newType] {
+		return nil, fmt.Errorf("invalid node type: %q", newType)
+	}
+
+	// Fetch the parent node to inherit project/scope.
+	parent, err := e.store.GetNode(ctx, nodeID)
+	if err != nil {
+		return nil, fmt.Errorf("branch: parent not found: %w", err)
+	}
+
+	// Compute content hash for the new node.
+	h := sha256.Sum256([]byte(newContent + "\x00" + parent.Scope + "\x00" + parent.Project))
+	hash := fmt.Sprintf("%x", h)
+
+	node := &storage.Node{
+		ID:          uuid.New().String(),
+		Type:        newType,
+		Content:     newContent,
+		ContentHash: hash,
+		Scope:       parent.Scope,
+		Project:     parent.Project,
+		Tier:        defaultTier(newType),
+		Confidence:  1.0,
+		Version:     1,
+	}
+
+	e.mu.Lock()
+	defer e.mu.Unlock()
+
+	if err := e.graph.AddNode(ctx, node); err != nil {
+		return nil, fmt.Errorf("branch: create node failed: %w", err)
+	}
+
+	// Create an edge from the branched node back to the parent (DAG link).
+	edge := &storage.Edge{
+		ID:     uuid.New().String(),
+		FromID: node.ID,
+		ToID:   nodeID,
+		Type:   "caused_by",
+		Weight: 1.0,
+	}
+	if err := e.graph.AddEdge(ctx, edge); err != nil {
+		return nil, fmt.Errorf("branch: edge failed: %w", err)
+	}
+
+	return node, nil
+}

engine/branch_test.go

@@ -0,0 +1,116 @@
+package engine
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+
+	"github.com/GrayCodeAI/yaad/graph"
+	"github.com/GrayCodeAI/yaad/storage"
+)
+
+func TestBranch(t *testing.T) {
+	store, err := storage.NewStore(filepath.Join(t.TempDir(), "test.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer store.Close()
+
+	g := graph.New(store, store.DB())
+	eng := New(store, g)
+	defer eng.Close()
+	ctx := context.Background()
+
+	// Create a parent node via Remember
+	parent, err := eng.Remember(ctx, RememberInput{
+		Type:    "decision",
+		Content: "We chose PostgreSQL for the database layer",
+		Scope:   "project",
+		Project: "myproject",
+	})
+	if err != nil {
+		t.Fatalf("Remember parent: %v", err)
+	}
+
+	// Branch off a new node
+	branch, err := eng.Branch(ctx, parent.ID, "Actually, switching to SQLite for dev", "decision")
+	if err != nil {
+		t.Fatalf("Branch: %v", err)
+	}
+
+	// Verify the branch node exists and inherits project/scope
+	if branch.Project != parent.Project {
+		t.Errorf("project mismatch: got %q, want %q", branch.Project, parent.Project)
+	}
+	if branch.Scope != parent.Scope {
+		t.Errorf("scope mismatch: got %q, want %q", branch.Scope, parent.Scope)
+	}
+	if branch.Content != "Actually, switching to SQLite for dev" {
+		t.Errorf("content mismatch: got %q", branch.Content)
+	}
+	if branch.Type != "decision" {
+		t.Errorf("type mismatch: got %q, want %q", branch.Type, "decision")
+	}
+
+	// Verify edge from branch → parent exists
+	edges, err := store.GetEdgesFrom(ctx, branch.ID)
+	if err != nil {
+		t.Fatalf("GetEdgesFrom: %v", err)
+	}
+	found := false
+	for _, e := range edges {
+		if e.ToID == parent.ID && e.Type == "caused_by" {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Error("expected edge from branch to parent not found")
+	}
+}
+
+func TestBranch_EmptyContent(t *testing.T) {
+	store, err := storage.NewStore(filepath.Join(t.TempDir(), "test.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer store.Close()
+
+	g := graph.New(store, store.DB())
+	eng := New(store, g)
+	defer eng.Close()
+	ctx := context.Background()
+
+	parent, err := eng.Remember(ctx, RememberInput{
+		Type:    "convention",
+		Content: "Use gofmt",
+		Scope:   "project",
+		Project: "proj",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = eng.Branch(ctx, parent.ID, "", "convention")
+	if err == nil {
+		t.Fatal("expected error for empty content")
+	}
+}
+
+func TestBranch_ParentNotFound(t *testing.T) {
+	store, err := storage.NewStore(filepath.Join(t.TempDir(), "test.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer store.Close()
+
+	g := graph.New(store, store.DB())
+	eng := New(store, g)
+	defer eng.Close()
+	ctx := context.Background()
+
+	_, err = eng.Branch(ctx, "nonexistent-id", "some content", "decision")
+	if err == nil {
+		t.Fatal("expected error for nonexistent parent")
+	}
+}

exportimport/langgraph.go

@@ -0,0 +1,126 @@
+package exportimport
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/GrayCodeAI/yaad/storage"
+)
+
+// LangGraphEntry represents a single entry in the LangGraph-compatible JSON format.
+type LangGraphEntry struct {
+	ID       string                 `json:"id"`
+	ParentID string                 `json:"parent_id,omitempty"`
+	Role     string                 `json:"role"`
+	Content  string                 `json:"content"`
+	Metadata map[string]interface{} `json:"metadata,omitempty"`
+}
+
+// ImportLangGraph imports LangGraph-format JSON into yaad storage.
+// Each entry is mapped to a yaad Node with Type="entity".
+// Returns the count of successfully imported nodes.
+func ImportLangGraph(ctx context.Context, store storage.Storage, jsonData []byte) (int, error) {
+	var entries []LangGraphEntry
+	if err := json.Unmarshal(jsonData, &entries); err != nil {
+		return 0, fmt.Errorf("parsing langgraph JSON: %w", err)
+	}
+
+	imported := 0
+	for _, entry := range entries {
+		if entry.ID == "" || entry.Content == "" {
+			continue
+		}
+
+		hash := fmt.Sprintf("%x", sha256.Sum256([]byte(entry.ID+entry.Content)))
+		node := &storage.Node{
+			ID:          entry.ID,
+			Type:        "entity",
+			Content:     entry.Content,
+			ContentHash: hash,
+			Confidence:  1.0,
+			Version:     1,
+			CreatedAt:   time.Now(),
+			UpdatedAt:   time.Now(),
+		}
+
+		// Map role to tags
+		if entry.Role != "" {
+			node.Tags = "role:" + entry.Role
+		}
+
+		// Store metadata as summary if present
+		if entry.Metadata != nil {
+			if metaBytes, err := json.Marshal(entry.Metadata); err == nil {
+				node.Summary = string(metaBytes)
+			}
+		}
+
+		if err := store.CreateNode(ctx, node); err != nil {
+			continue // skip duplicates
+		}
+		imported++
+
+		// Create edge to parent if parent_id is specified
+		if entry.ParentID != "" {
+			edge := &storage.Edge{
+				ID:        fmt.Sprintf("%s->%s", entry.ParentID, entry.ID),
+				FromID:    entry.ParentID,
+				ToID:      entry.ID,
+				Type:      "parent",
+				CreatedAt: time.Now(),
+			}
+			store.CreateEdge(ctx, edge) // best-effort
+		}
+	}
+
+	return imported, nil
+}
+
+// ExportForLangGraph exports yaad nodes for a project as LangGraph-compatible JSON.
+func ExportForLangGraph(ctx context.Context, store storage.Storage, project string) ([]byte, error) {
+	nodes, err := store.ListNodes(ctx, storage.NodeFilter{Project: project})
+	if err != nil {
+		return nil, fmt.Errorf("listing nodes: %w", err)
+	}
+
+	entries := make([]LangGraphEntry, 0, len(nodes))
+	for _, n := range nodes {
+		entry := LangGraphEntry{
+			ID:      n.ID,
+			Role:    extractRole(n.Tags),
+			Content: n.Content,
+		}
+
+		// Reconstruct metadata from summary
+		if n.Summary != "" {
+			var meta map[string]interface{}
+			if err := json.Unmarshal([]byte(n.Summary), &meta); err == nil {
+				entry.Metadata = meta
+			}
+		}
+
+		// Look up parent edge
+		edges, _ := store.GetEdgesTo(ctx, n.ID)
+		for _, e := range edges {
+			if e.Type == "parent" {
+				entry.ParentID = e.FromID
+				break
+			}
+		}
+
+		entries = append(entries, entry)
+	}
+
+	return json.MarshalIndent(entries, "", "  ")
+}
+
+// extractRole extracts the role from a tags string like "role:assistant".
+func extractRole(tags string) string {
+	if len(tags) > 5 && tags[:5] == "role:" {
+		return tags[5:]
+	}
+	return ""
+}