Add an updateMavenProject tool for "Maven > Update Project"

Editing a pom.xml had no way to take effect: until the project configuration
is updated, the workspace does not see the change, so a newly added dependency
is not on the classpath and everything using it still fails to compile. The
only way through was for a human to run Maven > Update Project by hand.

Expose m2e's IProjectConfigurationManager.updateProjectConfiguration with a
MavenUpdateRequest - the same thing the IDE action runs - taking the project
plus the forceDependencyUpdate ("Force Update of Snapshots/Releases") and
offline flags.

Marked longExecution: resolving dependencies can reach the network, and the
tool joins with the operation's cancellable monitor rather than a
NullProgressMonitor, so a slow update can be polled and aborted.

Author: gradusnikov

plugins/com.github.gradusnikov.eclipse.plugin.assistai.main/src/com/github/gradusnikov/eclipse/assistai/mcp/servers/EclipseIntegrationsMcpServer.java

@@ -290,6 +290,19 @@ public String runMavenBuild(
                 Optional.ofNullable(timeout).map(Integer::parseInt).orElse(0));
     }
 
+    @Tool(name = "updateMavenProject", longExecution = true,
+          description = "Runs the equivalent of the IDE's 'Maven > Update Project' action: re-reads the pom, re-resolves dependencies and reconfigures the project's classpath. Use this after editing a pom.xml - until it runs, the workspace does not see the change, so a newly added dependency is not on the classpath and code using it still fails to compile.",
+          type = "object")
+    public String updateMavenProject(
+            @ToolParam(name = "projectName", description = "The name of the Maven project to update (use listMavenProjects to find it)", required = true) String projectName,
+            @ToolParam(name = "forceDependencyUpdate", description = "If 'true', re-resolves snapshots and releases even when already cached (the 'Force Update of Snapshots/Releases' checkbox). Default: false", required = false) String forceDependencyUpdate,
+            @ToolParam(name = "offline", description = "If 'true', resolves only from the local repository without reaching the network. Default: false", required = false) String offline)
+    {
+        boolean force = Optional.ofNullable(forceDependencyUpdate).map(Boolean::parseBoolean).orElse(false);
+        boolean workOffline = Optional.ofNullable(offline).map(Boolean::parseBoolean).orElse(false);
+        return mavenService.updateMavenProject(projectName, force, workOffline);
+    }
+
     @Tool(name = "getEffectivePom", longExecution = true, description = "Gets the effective POM for a Maven project.", type = "object")
     public String getEffectivePom(
             @ToolParam(name = "projectName", description = "The name of the Maven project", required = true) String projectName)

plugins/com.github.gradusnikov.eclipse.plugin.assistai.main/src/com/github/gradusnikov/eclipse/assistai/mcp/services/MavenService.java

@@ -18,6 +18,8 @@
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 
+import org.eclipse.m2e.core.project.MavenUpdateRequest;
+
 import com.github.gradusnikov.eclipse.assistai.mcp.operations.Operation;
 import com.github.gradusnikov.eclipse.assistai.mcp.operations.OperationContext;
 import org.eclipse.core.runtime.NullProgressMonitor;
@@ -38,6 +40,12 @@
 @Creatable
 public class MavenService
 {
+    /**
+     * m2e's Maven nature. Hardcoded rather than taken from IMavenConstants, which lives in
+     * an internal package.
+     */
+    private static final String MAVEN_NATURE_ID = "org.eclipse.m2e.core.maven2Nature";
+
 
     @Inject
     ILog           logger;
@@ -229,6 +237,76 @@ private void executeMavenBuild( IMavenProjectFacade facade, List<String> goals,
         MavenPlugin.getProjectConfigurationManager().updateProjectConfiguration( facade.getProject(), monitor );
     }
 
+    /**
+     * The headless equivalent of the IDE's "Maven > Update Project" action: re-reads the
+     * pom, re-resolves dependencies and reconfigures the project's classpath and facets.
+     * <p>
+     * This is what a pom edit needs before the workspace reflects it - without it, a newly
+     * added dependency is simply not on the classpath and everything that uses it still
+     * fails to compile.
+     *
+     * @param projectName            the Maven project to update
+     * @param forceDependencyUpdate  re-resolve SNAPSHOT and release dependencies even when
+     *                               they are already cached (the "Force Update of
+     *                               Snapshots/Releases" checkbox)
+     * @param offline                work offline, resolving only from the local repository
+     */
+    public String updateMavenProject( String projectName, boolean forceDependencyUpdate, boolean offline )
+    {
+        Objects.requireNonNull( projectName, "Project name cannot be null" );
+
+        if ( projectName.isEmpty() )
+        {
+            throw new RuntimeException( "Error: Project name cannot be empty." );
+        }
+
+        IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject( projectName );
+        if ( !project.exists() )
+        {
+            throw new RuntimeException( "Error: Project '" + projectName + "' does not exist." );
+        }
+        if ( !project.isOpen() )
+        {
+            throw new RuntimeException( "Error: Project '" + projectName + "' is closed." );
+        }
+
+        try
+        {
+            if ( !project.hasNature( MAVEN_NATURE_ID ) )
+            {
+                throw new RuntimeException( "Error: Project '" + projectName + "' is not a Maven project." );
+            }
+
+            // Cancellable, unlike a NullProgressMonitor: resolving dependencies can reach
+            // the network and take a while, so the caller must be able to abort it.
+            IProgressMonitor monitor = OperationContext.current()
+                                                       .map( Operation::monitor )
+                                                       .map( IProgressMonitor.class::cast )
+                                                       .orElseGet( NullProgressMonitor::new );
+
+            MavenUpdateRequest request = new MavenUpdateRequest( project, offline, forceDependencyUpdate );
+            MavenPlugin.getProjectConfigurationManager().updateProjectConfiguration( request, monitor );
+
+            StringBuilder sb = new StringBuilder();
+            sb.append( "Updated Maven project '" ).append( projectName ).append( "'." );
+            if ( forceDependencyUpdate )
+            {
+                sb.append( " Dependencies were re-resolved." );
+            }
+            if ( offline )
+            {
+                sb.append( " Resolved offline, from the local repository only." );
+            }
+            sb.append( "\n\nUse getCompilationErrors to check the project after the update." );
+            return sb.toString();
+        }
+        catch ( CoreException e )
+        {
+            logger.error( "Error updating Maven project " + projectName, e );
+            throw new RuntimeException( "Error updating Maven project '" + projectName + "': " + e.getMessage(), e );
+        }
+    }
+
     /**
      * Gets the effective POM for a Maven project.
      * 

tests/com.github.gradusnikov.eclipse.plugin.assistai.main.tests/src/com/github/gradusnikov/eclipse/plugin/assistai/mcp/services/MavenServiceTest.java

@@ -167,6 +167,33 @@ public void afterEach() throws CoreException {
         }
     }
 
+    @Test
+    public void testUpdateMavenProject_ValidProject() {
+        try {
+            // Offline, so the test does not depend on the network.
+            String result = service.updateMavenProject(TEST_PROJECT_NAME, false, true);
+
+            assertTrue(result.contains("Updated Maven project"), result);
+            assertTrue(result.contains(TEST_PROJECT_NAME), result);
+        } catch (RuntimeException e) {
+            String message = String.valueOf(e.getMessage());
+            if (message.contains("is not a Maven project") || message.contains("Could not find Maven configuration")) {
+                // m2e configuration is not always available in the test environment.
+                assumeTrue(false, "Skipping: Maven configuration not available (" + message + ")");
+            }
+            throw e;
+        }
+    }
+
+    @Test
+    public void testUpdateMavenProject_InvalidProject() {
+        RuntimeException exception = assertThrows(RuntimeException.class, () -> {
+            service.updateMavenProject("NonExistentProject", false, false);
+        });
+
+        assertTrue(exception.getMessage().contains("does not exist"), exception.getMessage());
+    }
+
     @Test
     public void testRunMavenBuild_InvalidProject() {
         // Test with non-existent project