Merge branch 'main' into ci/parallel-e2e-plans

Author: wenytang-ms

CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to the "vscode-java-dependency" extension will be documented
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## 0.27.5
+
+- fix - Check GHCP modernization version before call gotoAgentMode command in https://github.com/microsoft/vscode-java-dependency/pull/1022
+- perf - Tune Java LSP tool selection guidance in https://github.com/microsoft/vscode-java-dependency/pull/1020
+
 ## 0.27.4
 
 - fix - Implement LSP tools for stable builds in https://github.com/microsoft/vscode-java-dependency/pull/1014

jdtls.ext/com.microsoft.jdtls.ext.core/src/com/microsoft/jdtls/ext/core/PackageCommand.java

@@ -16,6 +16,7 @@
 import java.util.Collections;
 import java.util.EnumMap;
 import java.util.HashMap;
+import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
@@ -371,7 +372,7 @@ private static List<PackageNode> getPackageRootChildren(PackageParams query, IPr
                 throw new CoreException(
                         new Status(IStatus.ERROR, JdtlsExtActivator.PLUGIN_ID, String.format("No package root found for %s", query.getPath())));
             }
-            List<Object> result = getPackageFragmentRootContent(packageRoot, query.isHierarchicalView(), pm);
+            List<Object> result = getPackageFragmentRootContent(packageRoot, query.isHierarchicalView(), query.getSyncPaths(), pm);
             ResourceSet resourceSet = new ResourceSet(result, query.isHierarchicalView());
             ResourceVisitor visitor = new JavaResourceVisitor(packageRoot.getJavaProject());
             resourceSet.accept(visitor);
@@ -508,8 +509,62 @@ private static List<PackageNode> getFolderChildren(PackageParams query, IProgres
      * @param pm the progress monitor
      */
     public static List<Object> getPackageFragmentRootContent(IPackageFragmentRoot root, boolean isHierarchicalView, IProgressMonitor pm) throws CoreException {
+        return getPackageFragmentRootContent(root, isHierarchicalView, null, pm);
+    }
+
+    public static List<Object> getPackageFragmentRootContent(IPackageFragmentRoot root, boolean isHierarchicalView, List<String> syncPaths, IProgressMonitor pm) throws CoreException {
         ArrayList<Object> result = new ArrayList<>();
-        refreshLocal(root.getResource(), pm);
+        IResource rootResource = root.getResource();
+        if (rootResource instanceof IContainer && rootResource.exists()
+                && root.getKind() == IPackageFragmentRoot.K_SOURCE) {
+            // Packages created out-of-band (e.g. by code generators or
+            // refactor-moves that write straight to disk) are otherwise never
+            // surfaced. A shallow DEPTH_ONE refresh only syncs the source root's
+            // immediate children and never discovers brand-new nested package
+            // folders. Even a DEPTH_INFINITE resource refresh is not enough on
+            // its own: the Java Model keeps a cached list of package fragments
+            // for the root, so closing it forces getChildren() below to rebuild
+            // that list from the freshly refreshed resource tree.
+            //
+            // On auto-refresh the client passes the changed resource URIs in
+            // syncPaths so we only deep-refresh those subtrees instead of the
+            // whole source tree. If any path cannot be resolved to an existing
+            // resource inside this root we conservatively fall back to a full
+            // DEPTH_INFINITE refresh so no package is ever missed.
+            // See https://github.com/microsoft/vscode-java-dependency/issues/914
+            boolean refreshedTargets = false;
+            if (syncPaths != null && !syncPaths.isEmpty()) {
+                Set<IResource> targets = new LinkedHashSet<>();
+                boolean allResolved = true;
+                for (String syncPath : syncPaths) {
+                    IResource target = findNearestExistingResource(syncPath, (IContainer) rootResource);
+                    if (target == null) {
+                        allResolved = false;
+                        break;
+                    }
+                    // Multiple changed paths can resolve to the same existing
+                    // ancestor (e.g. several new files in one new package); the
+                    // set keeps each distinct subtree so it is refreshed once.
+                    targets.add(target);
+                }
+                if (allResolved && !targets.isEmpty()) {
+                    for (IResource target : targets) {
+                        refreshLocal(target, IResource.DEPTH_INFINITE, pm);
+                    }
+                    refreshedTargets = true;
+                }
+            }
+            if (!refreshedTargets) {
+                refreshLocal(rootResource, IResource.DEPTH_INFINITE, pm);
+            }
+            try {
+                root.close();
+            } catch (JavaModelException e) {
+                JdtlsExtActivator.log(e);
+            }
+        } else {
+            refreshLocal(rootResource, IResource.DEPTH_ONE, pm);
+        }
         if (isHierarchicalView) {
             Map<String, IJavaElement> map = new HashMap<>();
             for (IJavaElement child : root.getChildren()) {
@@ -599,13 +654,56 @@ public static IJavaProject getJavaProject(String projectUri) {
     }
 
     private static void refreshLocal(IResource resource, IProgressMonitor monitor) {
+        refreshLocal(resource, IResource.DEPTH_ONE, monitor);
+    }
+
+    private static void refreshLocal(IResource resource, int depth, IProgressMonitor monitor) {
         if (resource == null || !resource.exists()) {
             return;
         }
         try {
-            resource.refreshLocal(IResource.DEPTH_ONE, monitor);
+            resource.refreshLocal(depth, monitor);
         } catch (CoreException e) {
             JdtlsExtActivator.log(e);
         }
     }
+
+    /**
+     * Resolve a changed resource URI to the nearest ancestor that already exists
+     * in the workspace resource tree and lives inside the given source root.
+     * Used to scope an auto-refresh to only the affected subtree. Returns null
+     * when the URI cannot be mapped to a resource within the root, in which case
+     * the caller falls back to a full refresh so no package is missed.
+     */
+    private static IResource findNearestExistingResource(String uriStr, IContainer root) {
+        if (StringUtils.isBlank(uriStr) || root == null) {
+            return null;
+        }
+        try {
+            URI uri = JDTUtils.toURI(uriStr);
+            if (uri == null) {
+                return null;
+            }
+            IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
+            IResource resource = null;
+            IFile[] files = wsRoot.findFilesForLocationURI(uri);
+            if (files.length > 0) {
+                resource = files[0];
+            } else {
+                IContainer[] containers = wsRoot.findContainersForLocationURI(uri);
+                if (containers.length > 0) {
+                    resource = containers[0];
+                }
+            }
+            while (resource != null && !resource.exists()) {
+                resource = resource.getParent();
+            }
+            if (resource != null && root.getFullPath().isPrefixOf(resource.getFullPath())) {
+                return resource;
+            }
+        } catch (Exception e) {
+            JdtlsExtActivator.logException("Failed to resolve sync path " + uriStr, e);
+        }
+        return null;
+    }
 }

jdtls.ext/com.microsoft.jdtls.ext.core/src/com/microsoft/jdtls/ext/core/PackageParams.java

@@ -11,6 +11,8 @@
 
 package com.microsoft.jdtls.ext.core;
 
+import java.util.List;
+
 import com.microsoft.jdtls.ext.core.model.NodeKind;
 
 /**
@@ -31,6 +33,14 @@ public class PackageParams {
 
     private boolean isHierarchicalView;
 
+    /**
+     * Optional list of resource URIs (sent by the client on auto-refresh) that
+     * have just changed on disk. When present, the server only refreshes the
+     * affected subtrees instead of deeply refreshing the whole source root.
+     * See https://github.com/microsoft/vscode-java-dependency/issues/914
+     */
+    private List<String> syncPaths;
+
     public PackageParams() {
     }
 
@@ -97,4 +107,12 @@ public void setRootPath(String rootPath) {
         this.rootPath = rootPath;
     }
 
+    public List<String> getSyncPaths() {
+        return syncPaths;
+    }
+
+    public void setSyncPaths(List<String> syncPaths) {
+        this.syncPaths = syncPaths;
+    }
+
 }

package-lock.json

@@ -2,7 +2,7 @@
   "name": "vscode-java-dependency",
   "displayName": "Project Manager for Java",
   "description": "%description%",
-  "version": "0.27.4",
+  "version": "0.27.5",
   "publisher": "vscjava",
   "preview": false,
   "aiKey": "5c642b22-e845-4400-badb-3f8509a70777",
@@ -52,8 +52,15 @@
       {
         "name": "lsp_java_getFileStructure",
         "toolReferenceName": "javaFileStructure",
-        "modelDescription": "Get the outline (classes, methods, fields) of a Java file with symbol kinds and line ranges.\n\nUse before read_file to find specific line ranges. For searching across files, use lsp_java_findSymbol instead.\n\nOnly use file paths confirmed from prior tool results or user input. If unsure, call lsp_java_findSymbol first.",
+        "modelDescription": "Get a known Java file's outline: classes, interfaces, methods, fields, symbol kinds, and line ranges, to pick a precise read_file range instead of reading the whole file.\n\nUse after lsp_java_findSymbol returns a file, or when the user gave a Java file path; do not guess paths. Not for workspace-wide search\u2014use lsp_java_findSymbol for that. Do not re-call for the same file unless the first result was empty.",
         "displayName": "Java: Get File Structure",
+        "userDescription": "Get a Java file outline with classes, methods, fields, and line ranges.",
+        "tags": [
+          "java",
+          "lsp",
+          "code-navigation",
+          "file-outline"
+        ],
         "canBeReferencedInPrompt": true,
         "icon": "$(symbol-class)",
         "when": "config.vscode-java-dependency.enableLspTools && javaLSReady",
@@ -73,8 +80,15 @@
       {
         "name": "lsp_java_findSymbol",
         "toolReferenceName": "javaFindSymbol",
-        "modelDescription": "Search for Java symbol definitions (classes, interfaces, methods, fields) across the entire workspace by name. Returns precise locations in ~60 tokens vs ~500+ tokens from grep_search.\n\nWhen to use:\n- To find where a class, method, or field is defined — faster and more precise than grep_search\n- To discover file paths before using other tools\n- Supports partial matching (e.g. 'UserSvc' finds 'UserServiceImpl')\n\nWhen NOT to use:\n- For non-Java files\n- To search for string literals, comments, or non-symbol text (use grep_search)",
+        "modelDescription": "Find Java class, interface, method, or field definitions across the workspace by name or partial identifier. Prefer over grep_search, file_search, semantic_search, or search subagents for Java symbol lookup.\n\nOn relevant results, do not repeat with a similar query; continue with lsp_java_getFileStructure or read_file on the returned line range. The tool retries internally, so on an empty result do not re-search\u2014retry once only if it reports indexing in progress, otherwise use generic search.\n\nDo not use for non-Java files, literals, comments, build/XML files, or conceptual exploration.",
         "displayName": "Java: Find Symbol",
+        "userDescription": "Find Java class, method, field, or interface definitions by name.",
+        "tags": [
+          "java",
+          "lsp",
+          "code-navigation",
+          "symbol-search"
+        ],
         "canBeReferencedInPrompt": true,
         "icon": "$(search)",
         "when": "config.vscode-java-dependency.enableLspTools && javaLSReady",

package.json

@@ -1,14 +1,15 @@
 ---
-description: REQUIRED for Java files. Provides compiler-accurate lsp_java_findSymbol and lsp_java_getFileStructure tools that replace grep_search, search_subagent, semantic_search, and file_search for Java symbol navigation.
+description: Use Java LSP tools for precise Java symbol navigation. Prefer lsp_java_findSymbol and lsp_java_getFileStructure over generic search only when locating Java classes, methods, fields, or file outlines.
 applyTo: '**/*.java'
 ---
 
-For Java files, two compiler-accurate `lsp_java_*` tools are available and return structured results in ~50 tokens vs ~500+ from generic search:
+For Java symbol navigation, two compiler-accurate `lsp_java_*` tools are available and return structured results with smaller, easier-to-interpret payloads than generic search:
 
 - `lsp_java_findSymbol(query)` — find class/method/field definitions by name across the workspace
 - `lsp_java_getFileStructure(uri)` — get file outline (classes, methods, fields) with line ranges
 
-These are deferred tools. Load them with `tool_search_tool_regex` using pattern `lsp_java_` before first use.
+If these tools are not already available in the current tool list, load them with `tool_search` using a query such as `Java LSP symbol navigation lsp_java`.
 
-Prefer these over `grep_search`, `search_subagent`, `semantic_search`, `file_search`, or full-file `read_file` when navigating Java symbols. Always use `findSymbol` to discover file paths before passing them to `getFileStructure` — do not guess paths. Fall back to `grep_search` if a tool returns empty or errors.
+Use `lsp_java_findSymbol` before `grep_search`, `search_subagent`, `semantic_search`, or `file_search` only when the task is to locate Java symbols by name or partial identifier. If it returns relevant symbols, do not call it again with the same or similar query; next use `lsp_java_getFileStructure` for the returned file or `read_file` on the smallest useful line range.
 
+Use `lsp_java_getFileStructure` only with a path confirmed by the user or a previous tool result. Do not guess paths. Use generic search for string literals, comments, XML, Gradle/Maven files, non-Java files, or broad conceptual exploration. `findSymbol` already retries internally with a normalized identifier, so do not re-issue the same search on an empty result: if it reports indexing in progress, retry once after a short pause; otherwise fall back to generic search.

resources/instruments/javaLspContext.instructions.md

@@ -1,41 +1,45 @@
 ---
 name: java-lsp-tools
-description: Compiler-accurate Java code navigation via the Java Language Server. Use lsp_java_findSymbol to locate symbols and lsp_java_getFileStructure to inspect file outlines. Prefer over grep_search for Java symbol navigation.
+description: Compiler-accurate Java symbol navigation via the Java Language Server. Use lsp_java_findSymbol for Java identifiers and lsp_java_getFileStructure for known Java files; prefer them over generic search only for symbol/file-outline navigation.
 ---
 
 # Java LSP Tools
 
-Two compiler-accurate tools backed by the Java Language Server (jdtls). They return structured JSON with fewer tokens than `grep_search` or `read_file`.
+Two compiler-accurate tools backed by the Java Language Server (jdtls). They return structured JSON that is easier to interpret than generic search results for Java symbol navigation.
 
 ## Tools
 
 ### `lsp_java_findSymbol`
 Search for Java symbol definitions (classes, methods, fields) by name across the workspace. Supports partial matching.
 - Input: `{ query, limit? }` — limit defaults to 20, max 50
-- Output: `{ name, kind, location }` per result (~60 tokens)
-- **Use instead of** `grep_search` when looking for where a class/method is defined
+- Output: `{ results: [{ name, kind, container?, location, range }], total }` (~60 tokens); `range` is `L start-end`
+- **Use instead of** `grep_search`, `file_search`, `semantic_search`, or `search_subagent` when looking for where a Java class/method/field is defined by identifier
+- Do not repeat with the same or similar query after relevant results are returned
 
 ### `lsp_java_getFileStructure`
 Get hierarchical outline of a Java file (classes, methods, fields) with line ranges.
 - Input: `{ uri }` — workspace-relative path. Must be a known path from prior tool results or user input — do not guess
 - Output: symbol tree with `L start-end` ranges (~100 tokens)
-- **Use instead of** `read_file` full scan when you need to understand a file's layout
+- **Use before** `read_file` when you need to choose a precise line range in a known Java file
 
 ## When to Use
 
 | Task | Use | Not |
 |---|---|---|
 | Find class/method/field definition | `lsp_java_findSymbol` | `grep_search` |
-| See file outline before reading | `lsp_java_getFileStructure` | `read_file` full file |
+| See known Java file outline before reading | `lsp_java_getFileStructure` | `read_file` full file |
 | Search non-Java files (xml, gradle) | `grep_search` | lsp tools |
 | Search string literals or comments | `grep_search` | lsp tools |
+| Explore broad concepts without identifiers | `semantic_search` or `search_subagent` | lsp tools |
 
 ## Typical Workflow
 
 **findSymbol → getFileStructure → read_file (specific lines only)**
 
+If `findSymbol` returns relevant symbols, move forward to `getFileStructure` or `read_file`; do not call `findSymbol` again with the same or similar identifier.
+
 ## Fallback
 
-- `findSymbol` returns empty → retry with shorter keyword, then fall back to `grep_search`
-- Path error → use `findSymbol` to discover correct path first
+- `findSymbol` returns empty → it already retried internally with a normalized identifier, so do not re-issue the same search. If the result says indexing is in progress, retry once after a short pause; otherwise fall back to `grep_search`
+- Path error (`fileNotFound`) → use `findSymbol` to discover the correct path first; do not guess paths
 - Tool error / jdtls not ready → fall back to `grep_search` + `read_file`, don't retry more than once

resources/skills/java-lsp-tools/SKILL.md

@@ -36,11 +36,15 @@ export namespace ExtensionName {
     export const APP_MODERNIZATION_FOR_JAVA = "vscjava.migrate-java-to-azure";
     // Java upgrade extension is merged into app modernization extension
     export const APP_MODERNIZATION_UPGRADE_FOR_JAVA = APP_MODERNIZATION_FOR_JAVA;
-    export const APP_MODERNIZATION_EXTENSION_NAME = "GitHub Copilot app modernization";
+    export const APP_MODERNIZATION_EXTENSION_NAME = "GitHub Copilot modernization";
 }
 
 export namespace Upgrade {
     export const PACKAGE_ID_FOR_JAVA_RUNTIME = "java:*";
+    /** Minimum version of the appmod extension that supports gotoAgentMode command */
+    export const MIN_APPMOD_VERSION = "1.15.0";
+    export const SOURCE_JAVA_UPGRADE = "vscode-java-dependency.java-upgrade";
+    export const SOURCE_CVE = "vscode-java-dependency.cve";
 }
 
 /**