fix(rename): add progress tracking to trigger reindex after rename

Without reindexing after a rename operation, the search index still
contains old module names. This causes subsequent renames to fail -
e.g., renaming `Dummy.Accounts` to `Dummy.Accounts2` works, but renaming
back to `Dummy.Accounts` fails to update `Dummy.Accounts2.User` because
the index doesn't know about the new module names.

Add Commands.Rename GenServer to track file_changed/file_saved events
and trigger reindexing once all rename operations complete.

Author: scottming

apps/engine/lib/engine.ex

@@ -67,6 +67,10 @@ defmodule Engine do
 
   defdelegate rename(analysis, position, new_name, client_name), to: Engine.CodeMod.Rename
 
+  defdelegate maybe_update_rename_progress(triggered_message),
+    to: Engine.Commands.Rename,
+    as: :update_progress
+
   def list_apps do
     for {app, _, _} <- :application.loaded_applications(),
         not Forge.Namespace.Module.prefixed?(app),

apps/engine/lib/engine/application.ex

@@ -10,6 +10,7 @@ defmodule Engine.Application do
         [
           Engine.Api.Proxy,
           Engine.Commands.Reindex,
+          Engine.Commands.RenameSupervisor,
           Engine.Module.Loader,
           Engine.Dispatch,
           Engine.ModuleMappings,

apps/engine/lib/engine/code_mod/rename.ex

@@ -7,11 +7,15 @@ defmodule Engine.CodeMod.Rename do
   rename execution.
   """
   alias Engine.CodeMod.Rename
+  alias Engine.Commands
+  alias Engine.Progress
   alias Forge.Ast.Analysis
   alias Forge.Document
   alias Forge.Document.Position
   alias Forge.Document.Range
 
+  import Forge.EngineApi.Messages
+
   @doc """
   Prepares a rename operation at the given position.
 
@@ -31,16 +35,94 @@ defmodule Engine.CodeMod.Rename do
   Renames the entity at the given position to `new_name`, returning a list
   of document changes that should be applied.
 
-  The `client_name` parameter is currently unused but reserved for future
-  client-specific behavior (e.g., different progress tracking for VSCode vs Neovim).
+  The `client_name` parameter is used to determine client-specific behavior
+  for progress tracking (e.g., VSCode sends different events than Neovim).
   """
   @spec rename(Analysis.t(), Position.t(), String.t(), String.t() | nil) ::
           {:ok, [Document.Changes.t()]} | {:error, term()}
-  def rename(%Analysis{} = analysis, %Position{} = position, new_name, _client_name) do
+  def rename(%Analysis{} = analysis, %Position{} = position, new_name, client_name) do
     with {:ok, {renamable, entity}, range} <- Rename.Prepare.resolve(analysis, position) do
       rename_module = Map.fetch!(@rename_mappings, renamable)
       results = rename_module.rename(range, new_name, entity)
+      set_rename_progress(results, client_name)
       {:ok, results}
     end
   end
+
+  defp set_rename_progress(document_changes_list, client_name) do
+    # Progress tracking is optional - if the infrastructure isn't running
+    # (e.g., in tests), we just skip it
+    try do
+      do_set_rename_progress(document_changes_list, client_name)
+    rescue
+      _ -> :ok
+    catch
+      :exit, _ -> :ok
+    end
+  end
+
+  defp do_set_rename_progress(document_changes_list, client_name) do
+    uri_to_expected_operation =
+      uri_to_expected_operation(client_name, document_changes_list)
+
+    {paths_to_delete, paths_to_reindex} =
+      for %Document.Changes{rename_file: rename_file, document: document} <- document_changes_list do
+        if rename_file do
+          {rename_file.old_uri, rename_file.new_uri}
+        else
+          {nil, document.uri}
+        end
+      end
+      |> Enum.unzip()
+
+    paths_to_delete = Enum.reject(paths_to_delete, &is_nil/1)
+    renaming_operation_count = Enum.count(uri_to_expected_operation)
+
+    total_operation_count =
+      renaming_operation_count + length(paths_to_delete) + length(paths_to_reindex)
+
+    {on_update_progress, on_complete} =
+      Progress.begin_percent("Renaming", total_operation_count)
+
+    Commands.RenameSupervisor.start_renaming(
+      uri_to_expected_operation,
+      paths_to_reindex,
+      paths_to_delete,
+      on_update_progress,
+      on_complete
+    )
+  end
+
+  # VSCode sends both file_changed and file_saved events
+  defp uri_to_expected_operation(client_name, document_changes_list)
+       when client_name in ["Visual Studio Code"] do
+    document_changes_list
+    |> Enum.flat_map(fn %Document.Changes{document: document, rename_file: rename_file} ->
+      if rename_file do
+        # when the file is renamed, we won't receive `DidSave` for the old file
+        [
+          {rename_file.old_uri, file_changed(uri: rename_file.old_uri)},
+          {rename_file.new_uri, file_saved(uri: rename_file.new_uri)}
+        ]
+      else
+        [{document.uri, file_saved(uri: document.uri)}]
+      end
+    end)
+    |> Map.new()
+  end
+
+  # Other editors (like Neovim) may only send file_changed events
+  defp uri_to_expected_operation(_, document_changes_list) do
+    document_changes_list
+    |> Enum.flat_map(fn %Document.Changes{document: document, rename_file: rename_file} ->
+      if rename_file do
+        [{rename_file.new_uri, file_saved(uri: rename_file.new_uri)}]
+      else
+        # Some editors do not directly save the file after renaming, such as *neovim*.
+        # when the file is not renamed, we'll only received `DidChange` for the old file
+        [{document.uri, file_changed(uri: document.uri)}]
+      end
+    end)
+    |> Map.new()
+  end
 end

apps/engine/lib/engine/commands/rename.ex

@@ -0,0 +1,206 @@
+defmodule Engine.Commands.Rename do
+  @moduledoc """
+  Tracks rename progress and triggers reindexing after rename operations complete.
+
+  This GenServer is started when a rename operation begins. It tracks expected file
+  operations (file_changed, file_saved) and when all operations are received, it
+  reindexes the modified files and clears old entries from the search index.
+
+  This is necessary because after a rename, the search index still contains the old
+  module names. Without reindexing, subsequent renames won't find the new entries.
+  """
+
+  alias Engine.Commands.Reindex
+  alias Engine.Search.Store
+  alias Forge.EngineApi.Messages
+
+  require Logger
+  import Messages
+
+  use GenServer
+
+  defmodule State do
+    @moduledoc false
+
+    @type uri_to_expected_operation :: %{
+            Forge.uri() => Messages.file_changed() | Messages.file_saved()
+          }
+
+    @type t :: %__MODULE__{
+            uri_to_expected_operation: uri_to_expected_operation(),
+            paths_to_reindex: list(Forge.uri()),
+            paths_to_delete: list(Forge.uri()),
+            on_update_progress: (integer(), String.t() -> :ok),
+            on_complete: (-> :ok)
+          }
+
+    defstruct uri_to_expected_operation: %{},
+              paths_to_reindex: [],
+              paths_to_delete: [],
+              on_update_progress: nil,
+              on_complete: nil
+
+    def new(
+          uri_to_expected_operation,
+          paths_to_reindex,
+          paths_to_delete,
+          on_update_progress,
+          on_complete
+        ) do
+      %__MODULE__{
+        uri_to_expected_operation: uri_to_expected_operation,
+        paths_to_reindex: paths_to_reindex,
+        paths_to_delete: paths_to_delete,
+        on_update_progress: on_update_progress,
+        on_complete: on_complete
+      }
+    end
+
+    def update_progress(%__MODULE__{} = state, file_changed(uri: uri)) do
+      update_progress(state, uri, file_changed(uri: uri))
+    end
+
+    def update_progress(%__MODULE__{} = state, file_saved(uri: uri)) do
+      update_progress(state, uri, file_saved(uri: uri))
+    end
+
+    defp update_progress(%__MODULE__{} = state, uri, message) do
+      new_uri_with_expected_operation =
+        maybe_pop_expected_operation(
+          state.uri_to_expected_operation,
+          uri,
+          message,
+          state.on_update_progress
+        )
+
+      if Enum.empty?(new_uri_with_expected_operation) do
+        reindex_all_modified_files(state)
+        state.on_complete.()
+      end
+
+      %__MODULE__{state | uri_to_expected_operation: new_uri_with_expected_operation}
+    end
+
+    def in_progress?(%__MODULE__{} = state) do
+      state.uri_to_expected_operation != %{}
+    end
+
+    defp maybe_pop_expected_operation(uri_to_operation, uri, message, on_update_progress) do
+      case uri_to_operation do
+        %{^uri => ^message} ->
+          on_update_progress.(1, "")
+          Map.delete(uri_to_operation, uri)
+
+        _ ->
+          uri_to_operation
+      end
+    end
+
+    defp reindex_all_modified_files(%__MODULE__{} = state) do
+      Enum.each(state.paths_to_reindex, fn uri ->
+        Reindex.uri(uri)
+        state.on_update_progress.(1, "reindexing")
+      end)
+
+      Enum.each(state.paths_to_delete, fn uri ->
+        Store.clear(uri)
+        state.on_update_progress.(1, "deleting old index")
+      end)
+    end
+  end
+
+  @spec child_spec(
+          %{Forge.uri() => Messages.file_changed() | Messages.file_saved()},
+          list(Forge.uri()),
+          list(Forge.uri()),
+          (integer(), String.t() -> :ok),
+          (-> :ok)
+        ) :: Supervisor.child_spec()
+  def child_spec(
+        uri_to_expected_operation,
+        paths_to_reindex,
+        paths_to_delete,
+        on_update_progress,
+        on_complete
+      ) do
+    %{
+      id: __MODULE__,
+      start:
+        {__MODULE__, :start_link,
+         [
+           uri_to_expected_operation,
+           paths_to_reindex,
+           paths_to_delete,
+           on_update_progress,
+           on_complete
+         ]},
+      restart: :transient
+    }
+  end
+
+  def start_link(
+        uri_to_expected_operation,
+        paths_to_reindex,
+        paths_to_delete,
+        on_update_progress,
+        on_complete
+      ) do
+    state =
+      State.new(
+        uri_to_expected_operation,
+        paths_to_reindex,
+        paths_to_delete,
+        on_update_progress,
+        on_complete
+      )
+
+    GenServer.start_link(__MODULE__, state, name: __MODULE__)
+  end
+
+  @impl true
+  def init(state) do
+    {:ok, state, {:continue, :start_buffering}}
+  end
+
+  @doc """
+  Updates the rename progress with a file operation message.
+
+  This should be called when files are changed or saved during rename.
+  Returns `:ok` if the message was processed, `{:error, :not_in_rename_progress}`
+  if no rename is in progress.
+  """
+  @spec update_progress(Messages.file_changed() | Messages.file_saved()) ::
+          :ok | {:error, :not_in_rename_progress}
+  def update_progress(message) do
+    pid = Process.whereis(__MODULE__)
+
+    if pid && Process.alive?(pid) do
+      GenServer.cast(__MODULE__, {:update_progress, message})
+    else
+      {:error, :not_in_rename_progress}
+    end
+  end
+
+  @impl true
+  def handle_continue(:start_buffering, state) do
+    Engine.Api.Proxy.start_buffering()
+    {:noreply, state}
+  end
+
+  @impl true
+  def handle_call(:in_progress?, _from, state) do
+    {:reply, State.in_progress?(state), state}
+  end
+
+  @impl true
+  def handle_cast({:update_progress, message}, state) do
+    new_state = State.update_progress(state, message)
+
+    if State.in_progress?(new_state) do
+      {:noreply, new_state}
+    else
+      Logger.info("Rename process completed.")
+      {:stop, :normal, new_state}
+    end
+  end
+end

apps/engine/lib/engine/commands/rename_supervisor.ex

@@ -0,0 +1,58 @@
+defmodule Engine.Commands.RenameSupervisor do
+  @moduledoc """
+  DynamicSupervisor for managing rename progress tracking GenServers.
+
+  Each rename operation spawns a transient child that tracks progress
+  and shuts down when the rename is complete.
+  """
+
+  alias Engine.Commands.Rename
+
+  use DynamicSupervisor
+
+  def child_spec(_) do
+    %{
+      id: __MODULE__,
+      start: {__MODULE__, :start_link, []}
+    }
+  end
+
+  def start_link do
+    DynamicSupervisor.start_link(__MODULE__, [], name: __MODULE__)
+  end
+
+  @doc """
+  Starts a new rename progress tracker.
+
+  ## Parameters
+
+  - `uri_to_expected_operation` - Map of URIs to expected messages (file_changed/file_saved)
+  - `paths_to_reindex` - List of URIs that need to be reindexed after rename
+  - `paths_to_delete` - List of URIs whose entries should be deleted from the index
+  - `on_update_progress` - Callback function receiving (increment, message)
+  - `on_complete` - Callback function called when rename is complete
+  """
+  def start_renaming(
+        uri_to_expected_operation,
+        paths_to_reindex,
+        paths_to_delete,
+        on_update_progress,
+        on_complete
+      ) do
+    DynamicSupervisor.start_child(
+      __MODULE__,
+      Rename.child_spec(
+        uri_to_expected_operation,
+        paths_to_reindex,
+        paths_to_delete,
+        on_update_progress,
+        on_complete
+      )
+    )
+  end
+
+  @impl true
+  def init(_init_arg) do
+    DynamicSupervisor.init(strategy: :one_for_one)
+  end
+end