feat: update

Author: wenytang-ms

docs/java-context-tools-design.md

@@ -28,19 +28,19 @@
 | Tool | 粒度 | 用途 | 典型 token 量 |
 |------|------|------|--------------|
 | `java_getProjectContext` | L0 | 项目级概览 | ~100 |
-| `java_getFileImports` | L0 | 文件的 import 列表 | ~80 |
+| `lsp_java_getFileImports` | L0 | 文件的 import 列表 | ~80 |
 | `java_getClassDetail` | L1 | 单个类的签名+方法列表 | ~150 |
 | `java_getDependencyDetails` | L1 | 指定依赖的 GAV+scope | ~50 |
 
 ### 与 LSP 标准 Tool 的配合
 
 | 标准 LSP Tool（VS Code 内置命令封装） | 粒度 | 对应 LSP 请求 |
 |--------------------------------------|------|-------------|
-| `java_getFileStructure` | L0 | `textDocument/documentSymbol` |
-| `java_findSymbol` | L0 | `workspace/symbol` |
-| `java_getTypeAtPosition` | L1 | `textDocument/hover` (后处理) |
-| `java_getCallHierarchy` | L1 | `callHierarchy/incomingCalls` + `outgoingCalls` |
-| `java_getTypeHierarchy` | L1 | `typeHierarchy/supertypes` + `subtypes` |
+| `lsp_java_getFileStructure` | L0 | `textDocument/documentSymbol` |
+| `lsp_java_findSymbol` | L0 | `workspace/symbol` |
+| `lsp_java_getTypeAtPosition` | L1 | `textDocument/hover` (后处理) |
+| `lsp_java_getCallHierarchy` | L1 | `callHierarchy/incomingCalls` + `outgoingCalls` |
+| `lsp_java_getTypeHierarchy` | L1 | `typeHierarchy/supertypes` + `subtypes` |
 
 ---
 
@@ -97,7 +97,7 @@ java.project.getProjectContext(fileUri) → ProjectContextResult
 
 ---
 
-## Tool 2: `java_getFileImports`
+## Tool 2: `lsp_java_getFileImports`
 
 **用途**：快速了解一个 Java 文件引用了哪些类型，但不展开细节。
 
@@ -283,23 +283,23 @@ java.project.getDependencyDetails(fileUri, query?) → DependencyDetailsResult
 
 这些工具直接封装 VS Code 内置命令，不需要新的 Java 后端命令。
 
-### Tool 5: `java_getFileStructure`
+### Tool 5: `lsp_java_getFileStructure`
 
 封装 `vscode.executeDocumentSymbolProvider`，返回文件的类/方法/字段树。
 
-### Tool 6: `java_findSymbol`
+### Tool 6: `lsp_java_findSymbol`
 
 封装 `vscode.executeWorkspaceSymbolProvider`，全局模糊搜索符号。
 
-### Tool 7: `java_getTypeAtPosition`
+### Tool 7: `lsp_java_getTypeAtPosition`
 
 封装 `vscode.executeHoverProvider` + 后处理提取类型签名。
 
-### Tool 8: `java_getCallHierarchy`
+### Tool 8: `lsp_java_getCallHierarchy`
 
 封装 `vscode.prepareCallHierarchy` + `vscode.provideIncomingCalls` / `vscode.provideOutgoingCalls`。
 
-### Tool 9: `java_getTypeHierarchy`
+### Tool 9: `lsp_java_getTypeHierarchy`
 
 封装 `vscode.prepareTypeHierarchy` + `vscode.provideSupertypes` / `vscode.provideSubtypes`。
 

docs/java-context-tools-skill.md

@@ -22,7 +22,7 @@ You have access to 6 Java-specific tools that provide **compiler-accurate** info
 
 ## Tool Reference
 
-### `java_getFileStructure`
+### `lsp_java_getFileStructure`
 
 **Purpose:** Get the structural outline of a Java file — classes, methods, fields with line ranges.
 
@@ -41,7 +41,7 @@ You have access to 6 Java-specific tools that provide **compiler-accurate** info
 
 ---
 
-### `java_findSymbol`
+### `lsp_java_findSymbol`
 
 **Purpose:** Find classes, interfaces, methods by name across the entire workspace.
 
@@ -60,7 +60,7 @@ You have access to 6 Java-specific tools that provide **compiler-accurate** info
 
 ---
 
-### `java_getFileImports`
+### `lsp_java_getFileImports`
 
 **Purpose:** Get all import statements from a Java file, classified by source (jdk/project/external).
 
@@ -75,11 +75,11 @@ You have access to 6 Java-specific tools that provide **compiler-accurate** info
 
 **Typical output size:** ~80 tokens
 
-**Important:** This tells you WHAT is imported but not HOW it's used. For details about a specific imported class, use `read_file` to read the relevant source or `java_getTypeAtPosition` on its usage.
+**Important:** This tells you WHAT is imported but not HOW it's used. For details about a specific imported class, use `read_file` to read the relevant source or `lsp_java_getTypeAtPosition` on its usage.
 
 ---
 
-### `java_getTypeAtPosition`
+### `lsp_java_getTypeAtPosition`
 
 **Purpose:** Get the exact resolved type of any expression at a specific source position.
 
@@ -99,7 +99,7 @@ You have access to 6 Java-specific tools that provide **compiler-accurate** info
 
 ---
 
-### `java_getCallHierarchy`
+### `lsp_java_getCallHierarchy`
 
 **Purpose:** Find all callers of a method (incoming) or all methods it calls (outgoing).
 
@@ -118,7 +118,7 @@ You have access to 6 Java-specific tools that provide **compiler-accurate** info
 
 ---
 
-### `java_getTypeHierarchy`
+### `lsp_java_getTypeHierarchy`
 
 **Purpose:** Find all supertypes or subtypes of a class/interface.
 
@@ -142,10 +142,10 @@ You have access to 6 Java-specific tools that provide **compiler-accurate** info
 ### Pattern 1: "Fix a bug in a Java file"
 
 ```
-1. java_getFileStructure(file)           → Understand what's in the file (100 tokens)
+1. lsp_java_getFileStructure(file)           → Understand what's in the file (100 tokens)
 2. read_file(file, relevant_lines)       → Read the buggy method
-3. [If needed] java_getFileImports(file) → Check what types are used (80 tokens)
-4. [If needed] java_getTypeAtPosition()  → Resolve ambiguous types (20 tokens)
+3. [If needed] lsp_java_getFileImports(file) → Check what types are used (80 tokens)
+4. [If needed] lsp_java_getTypeAtPosition()  → Resolve ambiguous types (20 tokens)
 5. Edit the file
 ```
 Total tool overhead: ~200 tokens (vs ~3000+ tokens if you blindly dump all imports)
@@ -154,44 +154,44 @@ Total tool overhead: ~200 tokens (vs ~3000+ tokens if you blindly dump all impor
 
 ```
 1. read_file(pom.xml or build.gradle)    → Check build tool, Java version, deps
-2. java_findSymbol("Main")              → Find entry points (60 tokens)
-3. java_getFileStructure(main_file)     → Understand main file (100 tokens)
-4. java_getFileImports(main_file)       → See what libraries are used (80 tokens)
+2. lsp_java_findSymbol("Main")              → Find entry points (60 tokens)
+3. lsp_java_getFileStructure(main_file)     → Understand main file (100 tokens)
+4. lsp_java_getFileImports(main_file)       → See what libraries are used (80 tokens)
 ```
 Total tool overhead: ~240 tokens
 
 ### Pattern 3: "Refactor a method signature"
 
 ```
-1. java_getCallHierarchy(method, "incoming")  → Find all callers (80 tokens)
+1. lsp_java_getCallHierarchy(method, "incoming")  → Find all callers (80 tokens)
 2. For each caller file:
-   java_getFileStructure(caller_file)          → Understand caller context (100 tokens)
+   lsp_java_getFileStructure(caller_file)          → Understand caller context (100 tokens)
 3. Edit all affected files
 ```
 
 ### Pattern 4: "Find all implementations of an interface"
 
 ```
-1. java_findSymbol("MyInterface")                     → Locate the interface (60 tokens)
-2. java_getTypeHierarchy(interface_pos, "subtypes")    → Find all impls (60 tokens)
+1. lsp_java_findSymbol("MyInterface")                     → Locate the interface (60 tokens)
+2. lsp_java_getTypeHierarchy(interface_pos, "subtypes")    → Find all impls (60 tokens)
 3. For key implementations:
-   java_getFileStructure(impl_file)                     → See what they override
+   lsp_java_getFileStructure(impl_file)                     → See what they override
 ```
 
 ### Pattern 5: "Understand dependency usage in a file"
 
 ```
-1. java_getFileImports(file)             → See all imports classified (80 tokens)
+1. lsp_java_getFileImports(file)             → See all imports classified (80 tokens)
 2. [For unfamiliar external types]:
-   java_getTypeAtPosition() on usage     → See the resolved type/method signature
+   lsp_java_getTypeAtPosition() on usage     → See the resolved type/method signature
 3. [If needed] read_file(pom.xml)        → Check dependency coordinates
 ```
 
 ---
 
 ## Anti-Patterns (What NOT to Do)
 
-### ❌ Don't call java_getTypeAtPosition on obvious types
+### ❌ Don't call lsp_java_getTypeAtPosition on obvious types
 
 ```java
 String name = "hello";     // Obviously String — don't call the tool
@@ -202,11 +202,11 @@ var result = service.process(input);  // Not obvious — DO call the tool
 
 You already know `java.util.List`, `java.lang.String`, `java.io.File`. Don't waste a tool call on them.
 
-### ❌ Don't call java_getFileStructure on small files
+### ❌ Don't call lsp_java_getFileStructure on small files
 
 If a file is < 100 lines, just use `read_file` directly. File structure is most valuable for large files.
 
-### ❌ Don't call java_getCallHierarchy without reading the method first
+### ❌ Don't call lsp_java_getCallHierarchy without reading the method first
 
 Understand what the method does before tracing its callers.
 
@@ -223,6 +223,6 @@ If a Java tool returns an error or empty result:
 **For dependency/project info not covered by these tools:**
 - Read `pom.xml` or `build.gradle` directly with `read_file`
 - Use `grep_search` to find dependency declarations
-- Use `java_getFileImports` to see what external libraries a file uses
+- Use `lsp_java_getFileImports` to see what external libraries a file uses
 
 **General rule:** If a Java-specific tool fails, fall back to the universal tools (`read_file`, `grep_search`, `list_code_usages`). Don't retry more than once.

docs/package-json-tools-snippet.jsonc

@@ -18,7 +18,7 @@
       }
     },
     {
-      "name": "java_getFileImports",
+      "name": "lsp_java_getFileImports",
       "tags": ["java", "imports", "file"],
       "modelDescription": "Get the classified import list of a Java file. Each import is tagged with its kind (class/interface/enum/annotation) and source (project/external/jdk). Returns ~80 tokens. Use this to understand what a file depends on WITHOUT reading the full source. Follow up with java_getClassDetail only for the 1-2 classes you actually need to understand — do NOT expand every import.",
       "displayName": "Java: Get File Imports",
@@ -74,7 +74,7 @@
       }
     },
     {
-      "name": "java_getFileStructure",
+      "name": "lsp_java_getFileStructure",
       "tags": ["java", "structure", "symbols", "outline"],
       "modelDescription": "Get the structural outline of a Java file: classes, methods, fields, and their line ranges — WITHOUT reading the file content. Returns ~100 tokens. Use this BEFORE read_file to understand what's in a large file, then read_file on specific line ranges. Much more efficient than reading the entire file.",
       "displayName": "Java: Get File Structure",
@@ -90,7 +90,7 @@
       }
     },
     {
-      "name": "java_findSymbol",
+      "name": "lsp_java_findSymbol",
       "tags": ["java", "search", "symbol", "workspace"],
       "modelDescription": "Search for classes, interfaces, methods, or fields by name across the entire Java workspace. Returns precise symbol definitions only (no comments, no string literals, no import statements). More accurate than grep_search for finding Java symbol definitions. Supports partial names and camelCase matching.",
       "displayName": "Java: Find Symbol",
@@ -106,7 +106,7 @@
       }
     },
     {
-      "name": "java_getTypeAtPosition",
+      "name": "lsp_java_getTypeAtPosition",
       "tags": ["java", "type", "inference", "hover"],
       "modelDescription": "Get the compiler-resolved type of any expression at a specific source position. Returns the EXACT type (~20 tokens), using the Java compiler's own type inference. Use this for: var declarations, lambda parameters, generic type arguments, chained method call return types. Do NOT use for obvious types like String literals or explicit type declarations.",
       "displayName": "Java: Get Type at Position",
@@ -130,7 +130,7 @@
       }
     },
     {
-      "name": "java_getCallHierarchy",
+      "name": "lsp_java_getCallHierarchy",
       "tags": ["java", "calls", "hierarchy", "impact"],
       "modelDescription": "Find all callers of a method (incoming) or all methods it calls (outgoing). More precise than list_code_usages — returns only actual method CALLS, not imports, declarations, or comments. Use 'incoming' before modifying a method signature to find all callers. Use 'outgoing' to understand what a method depends on.",
       "displayName": "Java: Get Call Hierarchy",
@@ -159,7 +159,7 @@
       }
     },
     {
-      "name": "java_getTypeHierarchy",
+      "name": "lsp_java_getTypeHierarchy",
       "tags": ["java", "inheritance", "hierarchy", "interface"],
       "modelDescription": "Find all supertypes or subtypes of a class/interface. Catches things grep misses: indirect implementations, anonymous classes, lambda implementations of functional interfaces. Use 'subtypes' when modifying an interface to find ALL implementations. Use 'supertypes' to understand the inheritance chain.",
       "displayName": "Java: Get Type Hierarchy",

lsp-ai-tools.md

@@ -695,7 +695,7 @@ class TypeQueryTool implements vscode.LanguageModelTool<{ uri: string; line: num
         }
       },
       {
-        "name": "java_findSymbol",
+        "name": "lsp_java_findSymbol",
         "displayName": "Find Symbol in Workspace",
         "modelDescription": "Search for a class, interface, method or field by name across the entire workspace. Returns exact matches with kind (Class/Interface/Method) and file location. More precise than grep - no noise from comments or imports.",
         "inputSchema": {

package.json

@@ -50,7 +50,7 @@
     ],
     "languageModelTools": [
       {
-        "name": "java_getFileStructure",
+        "name": "lsp_java_getFileStructure",
         "toolReferenceName": "javaFileStructure",
         "modelDescription": "Get the structure (classes, methods, fields, inner classes) of a Java file. Returns a hierarchical outline with symbol kinds and line ranges. Use this first when you need to understand a file's layout before reading specific sections.",
         "displayName": "Java: Get File Structure",
@@ -68,7 +68,7 @@
         }
       },
       {
-        "name": "java_findSymbol",
+        "name": "lsp_java_findSymbol",
         "toolReferenceName": "javaFindSymbol",
         "modelDescription": "Search for Java symbols (classes, interfaces, methods, fields) across the workspace by name. Supports partial/fuzzy matching. Use this to find where a class or method is defined.",
         "displayName": "Java: Find Symbol",
@@ -90,7 +90,7 @@
         }
       },
       {
-        "name": "java_getFileImports",
+        "name": "lsp_java_getFileImports",
         "toolReferenceName": "javaFileImports",
         "modelDescription": "Get all import statements from a Java file, classified by source (jdk/project/external).",
         "displayName": "Java: Get File Imports",
@@ -108,7 +108,7 @@
         }
       },
       {
-        "name": "java_getTypeAtPosition",
+        "name": "lsp_java_getTypeAtPosition",
         "toolReferenceName": "javaTypeAtPosition",
         "modelDescription": "Get the compiler-resolved type signature at a specific position. Returns fully qualified type, method signature, or field declaration. Use this when you see var, lambdas, or generics and need the exact type.",
         "displayName": "Java: Get Type at Position",
@@ -134,7 +134,7 @@
         }
       },
       {
-        "name": "java_getCallHierarchy",
+        "name": "lsp_java_getCallHierarchy",
         "toolReferenceName": "javaCallHierarchy",
         "modelDescription": "Get incoming callers or outgoing callees of a method. PREFER THIS over grep_search when you need to find which methods call a specific method — returns precise call sites without noise from comments, imports, or string matches. Use 'incoming' for callers, 'outgoing' for callees.",
         "displayName": "Java: Get Call Hierarchy",
@@ -166,7 +166,7 @@
         }
       },
       {
-        "name": "java_getTypeHierarchy",
+        "name": "lsp_java_getTypeHierarchy",
         "toolReferenceName": "javaTypeHierarchy",
         "modelDescription": "Get supertypes or subtypes/implementors of a type. PREFER THIS over grep_search('extends|implements') — returns only actual inheritance relationships. Use 'supertypes' for parents, 'subtypes' for children.",
         "displayName": "Java: Get Type Hierarchy",
@@ -1231,7 +1231,13 @@
     ],
     "chatSkills": [
       {
-        "path": "./resources/skills/java-context-tools/SKILL.md"
+        "path": "./resources/skills/java-lsp-tools/SKILL.md"
+      }
+    ],
+    "chatInstructions": [
+      {
+        "path": "./resources/instruments/loadJavaSkills.md",
+        "when": "java:projectManagerActivated"
       }
     ]
   },

resources/instruments/loadJavaSkills.md

@@ -0,0 +1,16 @@
+---
+description: Guidelines for using Java LSP tools when working with Java codebases
+applyTo: '**/*.java'
+---
+
+MANDATORY: For ANY Java code task (bug fixing, code analysis, refactoring):
+
+1. LOAD TOOLS FIRST — Call tool_search_tool_regex with pattern:
+   lsp_java_findSymbol|lsp_java_getFileStructure|lsp_java_getCallHierarchy|lsp_java_getTypeHierarchy|lsp_java_getTypeAtPosition|lsp_java_getFileImports
+
+2. ALWAYS prefer lsp_java_* tools over grep_search/read_file for .java files.
+   These tools provide compiler-accurate results with ~90% fewer tokens.
+
+3. Read the "java-lsp-tools" skill for detailed per-tool usage guidance.
+
+Do NOT skip step 1. Do NOT use grep_search as a substitute for lsp_java_* tools on .java files.