irmin: Implement Store.diff for tree comparison

Implements the previously stubbed diff function that compares two trees
and yields a sequence of changes (Add, Remove, Change).

The algorithm recursively traverses both trees and:
- Emits Remove for entries only in old tree
- Emits Add for entries only in new tree
- Emits Change for modified contents
- Handles subtree transitions (contents ↔ node)

lib/store.ml

···
     | `Remove of Tree.path
     | `Change of Tree.path * hash * hash ]
 
-  let diff _t ~old:_ ~new_:_ =
-    (* TODO: Implement tree diff *)
-    Seq.empty
+  let diff t ~old ~new_ =
+    let old_tree = read_tree t old in
+    let new_tree = read_tree t new_ in
+
+    let rec diff_trees prefix old_tree new_tree =
+      let old_entries = Tree.list old_tree [] in
+      let new_entries = Tree.list new_tree [] in
+
+      let old_names = List.map fst old_entries in
+      let new_names = List.map fst new_entries in
+
+      (* Entries only in old -> Remove *)
+      let removed =
+        old_names
+        |> List.filter (fun name -> not (List.mem name new_names))
+        |> List.to_seq
+        |> Seq.map (fun name -> `Remove (prefix @ [ name ]))
+      in
+
+      (* Entries only in new -> Add *)
+      let added =
+        new_names
+        |> List.filter (fun name -> not (List.mem name old_names))
+        |> List.to_seq
+        |> Seq.filter_map (fun name ->
+            match Tree.find new_tree [ name ] with
+            | Some content ->
+                let hash = F.hash_contents content in
+                Some (`Add (prefix @ [ name ], hash))
+            | None ->
+                (* It's a subtree - handled by added_subtrees recursion below *)
+                None)
+      in
+
+      (* Entries in both -> check for changes *)
+      let common =
+        List.filter (fun name -> List.mem name new_names) old_names
+      in
+      let changes =
+        common |> List.to_seq
+        |> Seq.flat_map (fun name ->
+            let path = prefix @ [ name ] in
+            let old_kind = List.assoc name old_entries in
+            let new_kind = List.assoc name new_entries in
+            match (old_kind, new_kind) with
+            | `Contents, `Contents -> (
+                match
+                  (Tree.find old_tree [ name ], Tree.find new_tree [ name ])
+                with
+                | Some old_c, Some new_c ->
+                    let old_h = F.hash_contents old_c in
+                    let new_h = F.hash_contents new_c in
+                    if F.hash_equal old_h new_h then Seq.empty
+                    else Seq.return (`Change (path, old_h, new_h))
+                | _ -> Seq.empty)
+            | `Node, `Node -> (
+                match
+                  ( Tree.find_tree old_tree [ name ],
+                    Tree.find_tree new_tree [ name ] )
+                with
+                | Some old_sub, Some new_sub -> diff_trees path old_sub new_sub
+                | _ -> Seq.empty)
+            | `Contents, `Node ->
+                (* Changed from contents to tree - remove old contents *)
+                Seq.return (`Remove path)
+                |> Seq.append
+                     (match Tree.find_tree new_tree [ name ] with
+                     | Some sub -> diff_trees path (Tree.empty ()) sub
+                     | None -> Seq.empty)
+            | `Node, `Contents ->
+                (* Changed from tree to contents - add new contents *)
+                (match Tree.find new_tree [ name ] with
+                  | Some c ->
+                      let new_h = F.hash_contents c in
+                      Seq.return (`Add (path, new_h))
+                  | None -> Seq.empty)
+                |> Seq.append
+                     (match Tree.find_tree old_tree [ name ] with
+                     | Some sub -> diff_trees path sub (Tree.empty ())
+                     | None -> Seq.empty))
+      in
+
+      (* Also recurse into added subtrees *)
+      let added_subtrees =
+        new_names
+        |> List.filter (fun name -> not (List.mem name old_names))
+        |> List.to_seq
+        |> Seq.flat_map (fun name ->
+            match Tree.find_tree new_tree [ name ] with
+            | Some sub -> diff_trees (prefix @ [ name ]) (Tree.empty ()) sub
+            | None -> Seq.empty)
+      in
+
+      (* Also recurse into removed subtrees *)
+      let removed_subtrees =
+        old_names
+        |> List.filter (fun name -> not (List.mem name new_names))
+        |> List.to_seq
+        |> Seq.flat_map (fun name ->
+            match Tree.find_tree old_tree [ name ] with
+            | Some sub -> diff_trees (prefix @ [ name ]) sub (Tree.empty ())
+            | None -> Seq.empty)
+      in
+
+      Seq.append removed
+        (Seq.append added
+           (Seq.append changes (Seq.append added_subtrees removed_subtrees)))
+    in
+    diff_trees [] old_tree new_tree
 end
 
 module Git = Make (Codec.Git)

test/test_irmin.ml

···
     Alcotest.test_case "backend test_and_set" `Quick test_backend_test_and_set;
   ]
 
+let test_store_diff () =
+  let backend = Backend.Memory.create_sha1 () in
+  let store = Store.Git.create ~backend in
+  (* Create first commit with two files *)
+  let tree1 = Tree.Git.empty () in
+  let tree1 = Tree.Git.add tree1 [ "file1.txt" ] "content1" in
+  let tree1 = Tree.Git.add tree1 [ "file2.txt" ] "content2" in
+  let hash1 = Tree.Git.hash tree1 ~backend in
+  (* Create second tree: modify file1, remove file2, add file3 *)
+  let tree2 = Tree.Git.empty () in
+  let tree2 = Tree.Git.add tree2 [ "file1.txt" ] "modified1" in
+  let tree2 = Tree.Git.add tree2 [ "file3.txt" ] "content3" in
+  let hash2 = Tree.Git.hash tree2 ~backend in
+  (* Compute diff *)
+  let changes = Store.Git.diff store ~old:hash1 ~new_:hash2 |> List.of_seq in
+  (* Check we have the expected changes *)
+  let has_remove_file2 =
+    List.exists
+      (function `Remove [ "file2.txt" ] -> true | _ -> false)
+      changes
+  in
+  let has_add_file3 =
+    List.exists
+      (function `Add ([ "file3.txt" ], _) -> true | _ -> false)
+      changes
+  in
+  let has_change_file1 =
+    List.exists
+      (function `Change ([ "file1.txt" ], _, _) -> true | _ -> false)
+      changes
+  in
+  Alcotest.(check bool) "file2 removed" true has_remove_file2;
+  Alcotest.(check bool) "file3 added" true has_add_file3;
+  Alcotest.(check bool) "file1 changed" true has_change_file1
+
 let store_tests =
   [
     Alcotest.test_case "store commit" `Quick test_store_commit;
     Alcotest.test_case "store branches" `Quick test_store_branches;
+    Alcotest.test_case "store diff" `Quick test_store_diff;
   ]
 
 let tree_format_tests =