fix: Module selection with -m now expands POM aggregators to children

When -m selects a nested aggregator (packaging=pom), the build now
includes all child modules under that aggregator plus their transitive
dependencies, matching Maven 4 behaviour. Previously, the filter
naively included all modules preceding the selected one in the
topological sort, which pulled in unrelated modules like docview and
uidesigner when selecting fpgui-examples.

The filter logic is moved from TReactorCommand to
TModuleRegistry.FilterBuildOrder for testability.

Author: graemeg

src/main/pascal/PasBuild.Command.Reactor.pas

@@ -128,69 +128,10 @@ procedure TReactorCommand.DisplayDependencyGraph;
 end;
 
 procedure TReactorCommand.FilterBuildOrderForSelectedModule(var BuildOrder: TList);
-var
-  I: Integer;
-  Module: TModuleInfo;
-  SelectedModuleInfo: TModuleInfo;
-  FilteredOrder: TList;
-  IncludeModule: Boolean;
 begin
-  { Find the selected module by name }
-  SelectedModuleInfo := nil;
-  for I := 0 to FRegistry.Modules.Count - 1 do
-  begin
-    Module := TModuleInfo(FRegistry.Modules[I]);
-    if CompareText(Module.Name, FSelectedModule) = 0 then
-    begin
-      SelectedModuleInfo := Module;
-      Break;
-    end;
-  end;
-
-  if SelectedModuleInfo = nil then
-  begin
+  FRegistry.FilterBuildOrder(BuildOrder, FSelectedModule);
+  if BuildOrder.Count = 0 then
     TUtils.LogError('Module not found: ' + FSelectedModule);
-    { Clear build order to signal error }
-    BuildOrder.Clear;
-    Exit;
-  end;
-
-  { Filter: Keep only modules that the selected module depends on (and the selected module itself) }
-  { The build order is topologically sorted, so all dependencies come before the selected module }
-  FilteredOrder := TList.Create;
-  try
-    for I := 0 to BuildOrder.Count - 1 do
-    begin
-      Module := TModuleInfo(BuildOrder[I]);
-      IncludeModule := False;
-
-      { Include the selected module itself }
-      if CompareText(Module.Name, FSelectedModule) = 0 then
-        IncludeModule := True
-      { Include if this module is a (direct or transitive) dependency of the selected module }
-      { Since build order is sorted, we only include modules up to and including selected }
-      else
-      begin
-        { Check if this module is transitively needed by selected module }
-        { For now, include all modules that come before selected in build order }
-        IncludeModule := True;
-      end;
-
-      if IncludeModule then
-        FilteredOrder.Add(Module);
-
-      { Stop once we've added the selected module }
-      if CompareText(Module.Name, FSelectedModule) = 0 then
-        Break;
-    end;
-
-    { Replace build order with filtered order }
-    BuildOrder.Clear;
-    for I := 0 to FilteredOrder.Count - 1 do
-      BuildOrder.Add(FilteredOrder[I]);
-  finally
-    FilteredOrder.Free;
-  end;
 end;
 
 function TReactorCommand.Execute: Integer;

src/main/pascal/PasBuild.Types.pas

@@ -230,6 +230,7 @@   TModuleRegistry = class
     function FindModuleByName(const AName: string): TModuleInfo;
     function FindModuleByPath(const APath: string): TModuleInfo;
     function GetBuildOrder: TList;
+    procedure FilterBuildOrder(var ABuildOrder: TList; const ASelectedModule: string);
     procedure ResolveArtifacts(AModule: TModuleInfo);
 
     property Modules: TObjectList read FModules;
@@ -565,6 +566,85 @@ function TModuleRegistry.GetBuildOrder: TList;
   end;
 end;
 
+procedure TModuleRegistry.FilterBuildOrder(var ABuildOrder: TList; const ASelectedModule: string);
+
+  procedure CollectTransitiveDeps(const AModuleName: string; ANeeded: TStringList);
+  var
+    Module: TModuleInfo;
+    I: Integer;
+  begin
+    if ANeeded.IndexOf(AModuleName) >= 0 then
+      Exit;
+    ANeeded.Add(AModuleName);
+
+    Module := FindModuleByName(AModuleName);
+    if Module = nil then
+      Exit;
+
+    for I := 0 to Module.Dependencies.Count - 1 do
+      CollectTransitiveDeps(Module.Dependencies[I], ANeeded);
+  end;
+
+var
+  SelectedModuleInfo: TModuleInfo;
+  Needed: TStringList;
+  FilteredOrder: TList;
+  Module: TModuleInfo;
+  I: Integer;
+begin
+  SelectedModuleInfo := FindModuleByName(ASelectedModule);
+  if SelectedModuleInfo = nil then
+  begin
+    ABuildOrder.Clear;
+    Exit;
+  end;
+
+  Needed := TStringList.Create;
+  try
+    Needed.Duplicates := dupIgnore;
+    Needed.Sorted := True;
+
+    { If selected module is an aggregator (POM), expand to its child modules (Maven 4 behaviour) }
+    if (SelectedModuleInfo.Config <> nil) and
+       (SelectedModuleInfo.Config.BuildConfig.ProjectType = ptPom) then
+    begin
+      { Add the aggregator itself (will be skipped at build time, but shown in summary) }
+      Needed.Add(ASelectedModule);
+
+      { Find all modules whose path is under this aggregator's path }
+      for I := 0 to FModules.Count - 1 do
+      begin
+        Module := TModuleInfo(FModules[I]);
+        if Pos(ExcludeTrailingPathDelimiter(SelectedModuleInfo.Path) + DirectorySeparator,
+               Module.Path) = 1 then
+          CollectTransitiveDeps(Module.Name, Needed);
+      end;
+    end
+    else
+      { Non-aggregator: just collect the module and its transitive dependencies }
+      CollectTransitiveDeps(ASelectedModule, Needed);
+
+    { Filter build order to only include needed modules, preserving topological order }
+    FilteredOrder := TList.Create;
+    try
+      for I := 0 to ABuildOrder.Count - 1 do
+      begin
+        Module := TModuleInfo(ABuildOrder[I]);
+        if Needed.IndexOf(Module.Name) >= 0 then
+          FilteredOrder.Add(Module);
+      end;
+
+      ABuildOrder.Clear;
+      for I := 0 to FilteredOrder.Count - 1 do
+        ABuildOrder.Add(FilteredOrder[I]);
+    finally
+      FilteredOrder.Free;
+    end;
+  finally
+    Needed.Free;
+  end;
+end;
+
 procedure TModuleRegistry.ResolveArtifacts(AModule: TModuleInfo);
 var
   VisitedModules: TStringList;