feat: metadata diff hopefully implemented now

lib/bds/desktop/shell_commands.ex

@@ -222,6 +222,41 @@ defmodule BDS.Desktop.ShellCommands do
     end)
   end
 
+  defp dispatch("repair_metadata_diff", project, params) do
+    items = normalize_metadata_diff_items(Map.get(params, "items", Map.get(params, :items, [])))
+    direction = Map.get(params, "direction", Map.get(params, :direction))
+
+    if items == [] do
+      {:error, %{action: "repair_metadata_diff", message: "No metadata diff items selected"}}
+    else
+      queue_task(project, "repair_metadata_diff", "Repair Metadata Diff", "Maintenance", fn report ->
+        report.(0.2, "Repairing metadata differences")
+        {:ok, _repair} = Maintenance.repair_metadata_diff(project.id, direction, items)
+        report.(0.9, "Refreshing metadata diff")
+        {:ok, metadata_diff} = Maintenance.metadata_diff(project.id)
+        report.(1.0, "Metadata diff repair complete")
+        metadata_diff_result(project.id, metadata_diff)
+      end)
+    end
+  end
+
+  defp dispatch("import_metadata_diff_orphans", project, params) do
+    orphans = normalize_metadata_diff_orphans(Map.get(params, "orphans", Map.get(params, :orphans, [])))
+
+    if orphans == [] do
+      {:error, %{action: "import_metadata_diff_orphans", message: "No orphan files selected"}}
+    else
+      queue_task(project, "import_metadata_diff_orphans", "Import Metadata Diff Orphans", "Maintenance", fn report ->
+        report.(0.2, "Importing orphan files")
+        {:ok, _import} = Maintenance.import_metadata_diff_orphans(project.id, orphans)
+        report.(0.9, "Refreshing metadata diff")
+        {:ok, metadata_diff} = Maintenance.metadata_diff(project.id)
+        report.(1.0, "Metadata diff import complete")
+        metadata_diff_result(project.id, metadata_diff)
+      end)
+    end
+  end
+
   defp dispatch("validate_translations", project, _params) do
     queue_task(project, "validate_translations", "Validate Translations", "Validation", fn report ->
       report.(0.2, "Checking published translations")
@@ -519,6 +554,25 @@ defmodule BDS.Desktop.ShellCommands do
     Map.new(map, fn {key, value} -> {to_string(key), stringify_value(value)} end)
   end
 
+  defp normalize_metadata_diff_items(items) when is_list(items) do
+    Enum.map(items, fn item ->
+      %{
+        entity_type: Map.get(item, :entity_type) || Map.get(item, "entity_type"),
+        entity_id: Map.get(item, :entity_id) || Map.get(item, "entity_id")
+      }
+    end)
+  end
+
+  defp normalize_metadata_diff_items(_items), do: []
+
+  defp normalize_metadata_diff_orphans(orphans) when is_list(orphans) do
+    Enum.map(orphans, fn orphan ->
+      %{file_path: Map.get(orphan, :file_path) || Map.get(orphan, "file_path")}
+    end)
+  end
+
+  defp normalize_metadata_diff_orphans(_orphans), do: []
+
   defp stringify_value(value) when is_map(value), do: stringify_map(value)
   defp stringify_value(value) when is_list(value), do: Enum.map(value, &stringify_value/1)
   defp stringify_value(value) when is_atom(value), do: Atom.to_string(value)

lib/bds/desktop/shell_live.ex

@@ -98,6 +98,8 @@ defmodule BDS.Desktop.ShellLive do
         |> assign(:template_editor_drafts, %{})
         |> assign(:chat_editor_inputs, %{})
         |> assign(:misc_editor_selected_pairs, %{})
+        |> assign(:metadata_diff_active_tabs, %{})
+        |> assign(:metadata_diff_field_filters, %{})
         |> assign(:shell_overlay, nil)
       |> assign(:output_entries, [])
      |> reload_shell(workbench)}
@@ -711,6 +713,46 @@ defmodule BDS.Desktop.ShellLive do
     {:noreply, MiscEditor.dismiss_selected(socket, &reload_shell/2, &append_output_entry/5)}
   end
 
+  def handle_event("repair_metadata_diff", %{"field" => field, "direction" => direction}, socket) do
+    case MiscEditor.metadata_diff_repair_request(socket, field, direction) do
+      {:ok, params} -> {:noreply, apply_shell_command(socket, "repair_metadata_diff", params)}
+      {:error, message} -> {:noreply, append_output_entry(socket, translate_for_socket(socket, "Metadata Diff"), message, nil, "error")}
+    end
+  end
+
+  def handle_event("import_metadata_diff_orphans", _params, socket) do
+    case MiscEditor.metadata_diff_orphan_import_request(socket) do
+      {:ok, params} -> {:noreply, apply_shell_command(socket, "import_metadata_diff_orphans", params)}
+      {:error, message} -> {:noreply, append_output_entry(socket, translate_for_socket(socket, "Metadata Diff"), message, nil, "error")}
+    end
+  end
+
+  def handle_event("select_metadata_diff_tab", %{"tab" => tab}, socket) do
+    tab_id = socket.assigns.current_tab.id
+
+    socket =
+      socket
+      |> assign(:metadata_diff_active_tabs, Map.put(socket.assigns.metadata_diff_active_tabs, tab_id, tab))
+      |> assign(:metadata_diff_field_filters, Map.delete(socket.assigns.metadata_diff_field_filters, tab_id))
+      |> assign_misc_editor()
+
+    {:noreply, socket}
+  end
+
+  def handle_event("toggle_metadata_diff_field", %{"field" => field}, socket) do
+    tab_id = socket.assigns.current_tab.id
+    current = Map.get(socket.assigns.metadata_diff_field_filters, tab_id)
+
+    next_filters =
+      if current == field do
+        Map.delete(socket.assigns.metadata_diff_field_filters, tab_id)
+      else
+        Map.put(socket.assigns.metadata_diff_field_filters, tab_id, field)
+      end
+
+    {:noreply, socket |> assign(:metadata_diff_field_filters, next_filters) |> assign_misc_editor()}
+  end
+
   def handle_event("open_duplicate_post", %{"id" => id, "title" => title}, socket) do
     {:noreply, open_sidebar_item(socket, %{"route" => "post", "id" => id, "title" => title, "subtitle" => "draft"}, :preview)}
   end
@@ -1586,8 +1628,8 @@ defmodule BDS.Desktop.ShellLive do
     ArgumentError -> nil
   end
 
-  defp apply_shell_command(socket, action) do
-    case ShellCommands.execute(action) do
+  defp apply_shell_command(socket, action, params \\ %{}) do
+    case ShellCommands.execute(action, params) do
       {:ok, result} -> apply_shell_command_result(socket, result)
       {:error, %{message: message}} -> append_output_entry(socket, command_title(action), message, nil, "error")
       {:error, reason} -> append_output_entry(socket, command_title(action), inspect(reason), nil, "error")

lib/bds/desktop/shell_live/misc_editor.ex

@@ -101,13 +101,64 @@ defmodule BDS.Desktop.ShellLive.MiscEditor do
     end
   end
 
+  def metadata_diff_repair_request(socket, field, direction) do
+    meta = meta(socket.assigns)
+    payload = Map.get(meta, :payload, %{})
+    items = Enum.map(Map.get(payload, :diff_reports, []), &normalize_metadata_diff_item/1)
+    tabs = metadata_diff_tabs(items, [])
+    active_tab = metadata_diff_active_tab(socket.assigns, tabs)
+
+    repair_items =
+      items
+      |> Enum.filter(&(&1.tab_id == active_tab))
+      |> Enum.filter(fn item -> Enum.any?(item.differences, &(diff_name(&1) == field)) end)
+      |> Enum.map(&%{"entity_type" => &1.entity_type, "entity_id" => &1.entity_id})
+
+    cond do
+      not metadata_diff_repairable_tab?(active_tab) ->
+        {:error, translated("No repair action available")}
+
+      repair_items == [] ->
+        {:error, translated("No metadata diff items selected")}
+
+      true ->
+        {:ok,
+         %{
+           "direction" => direction,
+           "field" => field,
+           "tab" => active_tab,
+           "items" => repair_items
+         }}
+    end
+  end
+
+  def metadata_diff_orphan_import_request(socket) do
+    meta = meta(socket.assigns)
+    payload = Map.get(meta, :payload, %{})
+    items = Enum.map(Map.get(payload, :diff_reports, []), &normalize_metadata_diff_item/1)
+    orphan_files = Enum.map(Map.get(payload, :orphan_reports, []), &normalize_metadata_diff_orphan/1)
+    tabs = metadata_diff_tabs(items, orphan_files)
+    active_tab = metadata_diff_active_tab(socket.assigns, tabs)
+
+    selected_orphans =
+      orphan_files
+      |> Enum.filter(&(&1.tab_id == active_tab))
+      |> Enum.map(&%{"file_path" => &1.file_path})
+
+    if selected_orphans == [] do
+      {:error, translated("No orphan files selected")}
+    else
+      {:ok, %{"tab" => active_tab, "orphans" => selected_orphans}}
+    end
+  end
+
   def build(%{current_tab: %{type: type}} = assigns) when type in @misc_routes do
     meta = meta(assigns)
     payload = Map.get(meta, :payload, %{})
 
     case type do
       :site_validation -> build_site_validation(meta, payload)
-      :metadata_diff -> build_metadata_diff(meta, payload)
+      :metadata_diff -> build_metadata_diff(assigns, meta, payload)
       :translation_validation -> build_translation_validation(meta, payload)
       :find_duplicates -> build_duplicates(assigns, meta, payload)
       :git_diff -> build_git_diff(assigns, meta)
@@ -151,17 +202,28 @@ defmodule BDS.Desktop.ShellLive.MiscEditor do
     }
   end
 
-  defp build_metadata_diff(meta, payload) do
-    items = Map.get(payload, :diff_reports, [])
+  defp build_metadata_diff(assigns, meta, payload) do
+    items = Enum.map(Map.get(payload, :diff_reports, []), &normalize_metadata_diff_item/1)
+    orphan_files = Enum.map(Map.get(payload, :orphan_reports, []), &normalize_metadata_diff_orphan/1)
+    tabs = metadata_diff_tabs(items, orphan_files)
+    active_tab = metadata_diff_active_tab(assigns, tabs)
+    active_field = metadata_diff_active_field(assigns)
+    current_tab = Enum.find(tabs, &(&1.id == active_tab)) || List.first(tabs) || empty_metadata_diff_tab()
+    filtered_items = metadata_diff_filtered_items(current_tab.items, active_field)
 
     %{
       kind: :metadata_diff,
       title: Map.get(meta, :title, translated("Metadata Diff")),
       subtitle: Map.get(meta, :subtitle, ""),
       summary: Map.get(payload, :summary, %{}),
-      field_summaries: field_summaries(items),
-      items: items,
-      orphan_files: Map.get(payload, :orphan_reports, [])
+      tabs: Enum.map(tabs, &Map.take(&1, [:id, :label, :badge_count, :diff_count, :orphan_count])),
+      active_tab: current_tab.id,
+      active_field: active_field,
+      repair_enabled: metadata_diff_repairable_tab?(current_tab.id),
+      field_summaries: field_summaries(current_tab.items),
+      items: filtered_items,
+      orphan_files: if(is_nil(active_field), do: current_tab.orphan_files, else: []),
+      empty_message: translated("No items")
     }
   end
 
@@ -247,8 +309,163 @@ defmodule BDS.Desktop.ShellLive.MiscEditor do
   defp field_summaries(items) do
     items
     |> Enum.flat_map(fn item -> Map.get(item, :differences) || Map.get(item, "differences") || [] end)
-    |> Enum.group_by(fn diff -> Map.get(diff, :field) || Map.get(diff, "field") end)
+    |> Enum.group_by(&diff_name/1)
     |> Enum.map(fn {field, diffs} -> %{field_name: field, diff_count: length(diffs)} end)
     |> Enum.sort_by(&{&1.diff_count * -1, &1.field_name})
   end
+
+  defp metadata_diff_tabs(items, orphan_files) do
+    tab_ids =
+      (Enum.map(items, & &1.tab_id) ++ Enum.map(orphan_files, & &1.tab_id))
+      |> Enum.uniq()
+      |> Enum.sort_by(&metadata_diff_tab_sort_key/1)
+
+    if tab_ids == [] do
+      [empty_metadata_diff_tab()]
+    else
+      Enum.map(tab_ids, fn tab_id ->
+        tab_items = Enum.filter(items, &(&1.tab_id == tab_id))
+        tab_orphans = Enum.filter(orphan_files, &(&1.tab_id == tab_id))
+
+        %{
+          id: tab_id,
+          label: metadata_diff_tab_label(tab_id),
+          items: tab_items,
+          orphan_files: tab_orphans,
+          diff_count: length(tab_items),
+          orphan_count: length(tab_orphans),
+          badge_count: length(tab_items) + length(tab_orphans)
+        }
+      end)
+    end
+  end
+
+  defp empty_metadata_diff_tab do
+    %{id: "posts", label: translated("Posts"), items: [], orphan_files: [], diff_count: 0, orphan_count: 0, badge_count: 0}
+  end
+
+  defp metadata_diff_active_tab(assigns, tabs) do
+    tab_id = Map.get(assigns.metadata_diff_active_tabs || %{}, assigns.current_tab.id)
+
+    if Enum.any?(tabs, &(&1.id == tab_id)) do
+      tab_id
+    else
+      tabs |> List.first() |> Map.get(:id)
+    end
+  end
+
+  defp metadata_diff_active_field(assigns) do
+    Map.get(assigns.metadata_diff_field_filters || %{}, assigns.current_tab.id)
+  end
+
+  defp metadata_diff_filtered_items(items, nil), do: items
+
+  defp metadata_diff_filtered_items(items, field) do
+    Enum.filter(items, fn item -> Enum.any?(item.differences, &(diff_name(&1) == field)) end)
+  end
+
+  defp normalize_metadata_diff_item(item) do
+    entity_type = Map.get(item, :entity_type) || Map.get(item, "entity_type") || "post"
+    entity_id = Map.get(item, :entity_id) || Map.get(item, "entity_id") || ""
+    differences =
+      item
+      |> Map.get(:differences, Map.get(item, "differences", []))
+      |> Enum.map(&normalize_metadata_diff_difference/1)
+
+    %{
+      tab_id: metadata_diff_tab_id(entity_type),
+      entity_type: entity_type,
+      entity_id: entity_id,
+      label: metadata_diff_item_label(item, entity_id),
+      display_entity_type: metadata_diff_item_type_label(entity_type),
+      differences: differences
+    }
+  end
+
+  defp normalize_metadata_diff_difference(diff) do
+    %{
+      field: diff_name(diff),
+      db_value: format_metadata_diff_value(Map.get(diff, :db_value) || Map.get(diff, "db_value")),
+      file_value: format_metadata_diff_value(Map.get(diff, :file_value) || Map.get(diff, "file_value"))
+    }
+  end
+
+  defp normalize_metadata_diff_orphan(orphan) do
+    path = Map.get(orphan, :file_path) || Map.get(orphan, "file_path") || Map.get(orphan, :path) || Map.get(orphan, "path") || ""
+    entity_type = Map.get(orphan, :entity_type) || Map.get(orphan, "entity_type") || metadata_diff_orphan_entity_type(path)
+
+    %{
+      tab_id: metadata_diff_tab_id(entity_type),
+      entity_type: entity_type,
+      file_path: path,
+      slug: Path.basename(path) |> String.trim(),
+      id: Map.get(orphan, :id) || Map.get(orphan, "id")
+    }
+  end
+
+  defp metadata_diff_item_label(item, entity_id) do
+    Map.get(item, :label) || Map.get(item, "label") || Map.get(item, :title) || Map.get(item, "title") || Map.get(item, :slug) || Map.get(item, "slug") || entity_id
+  end
+
+  defp metadata_diff_item_type_label("post"), do: translated("Post")
+  defp metadata_diff_item_type_label("post_translation"), do: translated("Translations")
+  defp metadata_diff_item_type_label("media"), do: translated("Media")
+  defp metadata_diff_item_type_label("media_translation"), do: translated("Translations")
+  defp metadata_diff_item_type_label("script"), do: translated("Script")
+  defp metadata_diff_item_type_label("template"), do: translated("Template")
+  defp metadata_diff_item_type_label("project"), do: translated("Project")
+  defp metadata_diff_item_type_label("publishing"), do: translated("Publishing")
+  defp metadata_diff_item_type_label("categories"), do: translated("Categories")
+  defp metadata_diff_item_type_label("category_meta"), do: translated("Categories")
+  defp metadata_diff_item_type_label("embedding"), do: translated("Embeddings")
+  defp metadata_diff_item_type_label(entity_type), do: entity_type |> String.replace("_", " ") |> String.capitalize()
+
+  defp metadata_diff_tab_id("post"), do: "posts"
+  defp metadata_diff_tab_id("post_translation"), do: "posts"
+  defp metadata_diff_tab_id("media"), do: "media"
+  defp metadata_diff_tab_id("media_translation"), do: "media"
+  defp metadata_diff_tab_id("script"), do: "scripts"
+  defp metadata_diff_tab_id("template"), do: "templates"
+  defp metadata_diff_tab_id("project"), do: "project"
+  defp metadata_diff_tab_id("publishing"), do: "project"
+  defp metadata_diff_tab_id("categories"), do: "project"
+  defp metadata_diff_tab_id("category_meta"), do: "project"
+  defp metadata_diff_tab_id("embedding"), do: "embeddings"
+  defp metadata_diff_tab_id(_entity_type), do: "project"
+
+  defp metadata_diff_tab_label("posts"), do: translated("Posts")
+  defp metadata_diff_tab_label("media"), do: translated("Media")
+  defp metadata_diff_tab_label("scripts"), do: translated("Scripts")
+  defp metadata_diff_tab_label("templates"), do: translated("Templates")
+  defp metadata_diff_tab_label("project"), do: translated("Project")
+  defp metadata_diff_tab_label("embeddings"), do: translated("Embeddings")
+  defp metadata_diff_tab_label(tab_id), do: tab_id |> String.replace("_", " ") |> String.capitalize()
+
+  defp metadata_diff_tab_sort_key("posts"), do: 0
+  defp metadata_diff_tab_sort_key("media"), do: 1
+  defp metadata_diff_tab_sort_key("scripts"), do: 2
+  defp metadata_diff_tab_sort_key("templates"), do: 3
+  defp metadata_diff_tab_sort_key("project"), do: 4
+  defp metadata_diff_tab_sort_key("embeddings"), do: 5
+  defp metadata_diff_tab_sort_key(other), do: {6, other}
+
+  defp metadata_diff_orphan_entity_type(path) do
+    cond do
+      String.starts_with?(path, "posts/") -> "post"
+      String.starts_with?(path, "media/") -> "media"
+      String.starts_with?(path, "scripts/") -> "script"
+      String.starts_with?(path, "templates/") -> "template"
+      true -> "project"
+    end
+  end
+
+  defp metadata_diff_repairable_tab?(tab_id), do: tab_id in ["posts", "media", "scripts", "templates", "project"]
+
+  defp format_metadata_diff_value(nil), do: "-"
+  defp format_metadata_diff_value(""), do: "-"
+  defp format_metadata_diff_value(value), do: to_string(value)
+
+  defp diff_name(diff) do
+    Map.get(diff, :field) || Map.get(diff, "field") || Map.get(diff, :name) || Map.get(diff, "name") || "value"
+  end
 end

lib/bds/desktop/shell_live/misc_editor_html/misc_editor.html.heex

@@ -31,10 +31,153 @@
         </div>
 
       <% :metadata_diff -> %>
-        <div class="misc-columns">
-          <section class="misc-card"><h3><%= translated("Field Summary") %></h3><div class="misc-summary-grid"><%= for field <- @misc_editor.field_summaries do %><span class="misc-summary-pill"><%= field.field_name %> <strong><%= field.diff_count %></strong></span><% end %></div></section>
-          <section class="misc-card"><h3><%= translated("Diff Items") %></h3><div class="misc-list"><%= for item <- @misc_editor.items do %><article class="misc-list-item"><header><strong><%= Map.get(item, :entity_type) || Map.get(item, "entity_type") %></strong> <span><%= Map.get(item, :entity_id) || Map.get(item, "entity_id") %></span></header><ul><%= for diff <- Map.get(item, :differences) || Map.get(item, "differences") || [] do %><li><strong><%= Map.get(diff, :field) || Map.get(diff, "field") %></strong><span><%= inspect(Map.get(diff, :db_value) || Map.get(diff, "db_value")) %></span><span><%= inspect(Map.get(diff, :file_value) || Map.get(diff, "file_value")) %></span></li><% end %></ul></article><% end %></div></section>
-          <section class="misc-card"><h3><%= translated("Orphan Files") %></h3><ul><%= for orphan <- @misc_editor.orphan_files do %><li><%= inspect(orphan) %></li><% end %></ul></section>
+        <div class="metadata-diff-tool">
+          <div class="metadata-diff-tabs" role="tablist">
+            <%= for tab <- @misc_editor.tabs do %>
+              <button
+                class={["metadata-diff-tab", if(@misc_editor.active_tab == tab.id, do: "active")]}
+                data-testid="metadata-diff-tab"
+                data-entity-tab={tab.id}
+                type="button"
+                phx-click="select_metadata_diff_tab"
+                phx-value-tab={tab.id}
+              >
+                <span><%= tab.label %></span>
+                <%= if tab.badge_count > 0 do %>
+                  <span class="tab-badge"><%= tab.badge_count %></span>
+                <% end %>
+              </button>
+            <% end %>
+          </div>
+
+          <%= if @misc_editor.field_summaries != [] do %>
+            <div class="metadata-diff-field-pills">
+              <%= for field <- @misc_editor.field_summaries do %>
+                <div class={["metadata-diff-field-pill", if(@misc_editor.active_field == field.field_name, do: "active")]}>
+                  <button
+                    class="metadata-diff-field-pill-toggle"
+                    data-testid="metadata-diff-field-pill"
+                    data-field={field.field_name}
+                    type="button"
+                    phx-click="toggle_metadata_diff_field"
+                    phx-value-field={field.field_name}
+                  >
+                    <span class="field-pill-label"><%= field.field_name %></span>
+                    <span class="field-pill-count"><%= field.diff_count %></span>
+                  </button>
+
+                  <%= if @misc_editor.repair_enabled do %>
+                    <div class="metadata-diff-field-pill-actions">
+                      <button
+                        class="secondary metadata-diff-action-button"
+                        data-testid="metadata-diff-repair-button"
+                        data-direction="db_to_file"
+                        data-field={field.field_name}
+                        type="button"
+                        phx-click="repair_metadata_diff"
+                        phx-value-direction="db_to_file"
+                        phx-value-field={field.field_name}
+                      >
+                        <%= translated("DB to File") %>
+                      </button>
+
+                      <button
+                        class="secondary metadata-diff-action-button"
+                        data-testid="metadata-diff-repair-button"
+                        data-direction="file_to_db"
+                        data-field={field.field_name}
+                        type="button"
+                        phx-click="repair_metadata_diff"
+                        phx-value-direction="file_to_db"
+                        phx-value-field={field.field_name}
+                      >
+                        <%= translated("File to DB") %>
+                      </button>
+                    </div>
+                  <% end %>
+                </div>
+              <% end %>
+            </div>
+          <% end %>
+
+          <div class="metadata-diff-results">
+            <%= if @misc_editor.items == [] do %>
+              <section class="misc-card metadata-diff-empty">
+                <p><%= @misc_editor.empty_message %></p>
+              </section>
+            <% else %>
+              <div class="diff-item-list">
+                <%= for item <- @misc_editor.items do %>
+                  <article class="diff-item-card" data-entity-type={item.entity_type}>
+                    <header class="diff-item-header">
+                      <div>
+                        <strong><%= item.label %></strong>
+                        <div class="diff-item-meta"><%= item.display_entity_type %> · <%= item.entity_id %></div>
+                      </div>
+                    </header>
+
+                    <div class="diff-item-fields">
+                      <%= for diff <- item.differences do %>
+                        <div class="diff-field-row" data-field={diff.field}>
+                          <div class="diff-field-name"><%= diff.field %></div>
+                          <div class="diff-field-values">
+                            <div class="diff-field-value db-value">
+                              <span class="diff-source-label">DB</span>
+                              <span><%= diff.db_value %></span>
+                            </div>
+                            <div class="diff-field-value file-value">
+                              <span class="diff-source-label"><%= translated("File") %></span>
+                              <span><%= diff.file_value %></span>
+                            </div>
+                          </div>
+                        </div>
+                      <% end %>
+                    </div>
+                  </article>
+                <% end %>
+              </div>
+            <% end %>
+
+            <%= if @misc_editor.active_field == nil and @misc_editor.orphan_files != [] do %>
+              <section class="orphan-files-section" data-testid="metadata-diff-orphans">
+                <div class="orphan-files-header">
+                  <h3><%= translated("Orphan Files") %></h3>
+                  <div class="orphan-files-actions">
+                    <span class="misc-summary-pill"><%= length(@misc_editor.orphan_files) %></span>
+                    <button
+                      class="secondary metadata-diff-action-button"
+                      data-testid="metadata-diff-import-button"
+                      type="button"
+                      phx-click="import_metadata_diff_orphans"
+                    >
+                      <%= translated("Import") %>
+                    </button>
+                  </div>
+                </div>
+                <div class="diff-item-list">
+                  <%= for orphan <- @misc_editor.orphan_files do %>
+                    <article class="diff-item-card orphan-file">
+                      <header class="diff-item-header">
+                        <div>
+                          <strong><%= orphan.slug %></strong>
+                          <div class="diff-item-meta"><%= translated("Orphan Files") %></div>
+                        </div>
+                      </header>
+
+                      <div class="diff-item-fields">
+                        <div class="diff-field-row">
+                          <div class="diff-field-name"><%= translated("Path") %></div>
+                          <div class="diff-field-values">
+                            <div class="diff-field-value file-value orphan-path"><span><%= orphan.file_path %></span></div>
+                          </div>
+                        </div>
+                      </div>
+                    </article>
+                  <% end %>
+                </div>
+              </section>
+            <% end %>
+          </div>
         </div>
 
       <% :translation_validation -> %>