Рефакторинг и навигация: 13 багфиксов, фильтрация символов, enum constants

Рефакторинг:
- rename: переименование конструкторов при rename класса (Java/Kotlin)
- rename: фильтрация unrelated параметров при rename поля (over-scope fix)
- extract_variable: изоляция выражений из statement (var decl, return, if)
- inline: fallback поиск локальных переменных через AST (extractOuterScopeVariables)
- delete: scope по умолчанию 'project' при handleReferences != 'error'
- wrap: throw RuntimeException вместо printStackTrace при оборачивании return
- generate: поддержка options.overwrite для перегенерации существующих методов
- CodeRefactorTool: 6 новых параметров в схеме, исправление what enum

Навигация:
- CodeNavigateTool: kind фильтр и brief режим для компактного вывода символов
- CodeNavigateTool: авторазрешение class vs constructor при ambiguity
- JavaSymbolExtractor: извлечение enum constants как CONSTANT символов

Author: Nefrols

app/src/main/java/ru/nts/tools/mcp/tools/navigation/CodeNavigateTool.java

@@ -90,16 +90,23 @@ public String getDescription() {
             - 'directory' (medium)
             - 'project' (slowest, scans up to 500 files)
 
+            SYMBOLS FILTERING (action='symbols' only):
+            - kind: filter by symbol kind (class, method, field, constructor, constant, etc.)
+            - brief: true for compact output (name + line only, no signatures/tokens)
+            - Combine both for minimal output: kind='method', brief=true
+
             PERFORMANCE TIPS:
             - Use scope='file' first, expand if needed
             - Prefer line/column over symbol name when possible
             - If a later edit depends on navigation, prefer strict=true to reject fallback cursor resolution
             - Large projects (1000+ files): expect delays for scope=project
+            - For large files (100+ symbols): use kind filter or brief=true to reduce output
 
             EXAMPLES:
             {"action":"definition", "path":"User.java", "line":42, "column":15}
             {"action":"references", "path":"User.java", "symbol":"getUserById", "scope":"file"}
             {"action":"symbols", "path":"User.java"}
+            {"action":"symbols", "path":"User.java", "kind":"method", "brief":true}
             {"action":"hover", "path":"User.java", "line":10}
 
             LANGUAGES: Java, Kotlin, JS/TS/TSX, Python, Go, Rust, C/C++, C#, PHP, HTML
@@ -144,6 +151,13 @@ public JsonNode getInputSchema() {
         props.putObject("strict").put("type", "boolean").put("description",
                 "For definition/references by position: require exact cursor resolution. If fallback or enclosing-symbol logic would be used, return no result.");
 
+        props.putObject("kind").put("type", "string").put("description",
+                "For 'symbols': filter by symbol kind. Values: class, interface, method, function, field, " +
+                "variable, constructor, constant, enum, property. Omit to show all symbols.");
+        props.putObject("brief").put("type", "boolean").put("description",
+                "For 'symbols': compact output — name and line only, no signatures, types, or tokens. " +
+                "Reduces output size for large files. Default: false.");
+
         var required = schema.putArray("required");
         required.add("action");
         required.add("path");
@@ -178,7 +192,7 @@ public JsonNode execute(JsonNode params) throws Exception {
             case "definition" -> executeDefinition(path, params);
             case "references" -> executeReferences(path, params);
             case "hover" -> executeHover(path, params);
-            case "symbols" -> executeSymbols(path);
+            case "symbols" -> executeSymbols(path, params);
             default -> throw new NtsException(NtsErrorCode.PARAM_INVALID, "action", action);
         };
     }
@@ -292,7 +306,11 @@ private JsonNode executeReferences(Path path, JsonNode params) throws IOExceptio
         if (symbolName != null && !symbolName.isEmpty()) {
             resolution = resolver.resolveDefinitionByName(path, symbolName);
             if ("ambiguous".equals(resolution.status())) {
-                return createAmbiguousResponse("references", resolution);
+                // Auto-resolve: if one candidate is CLASS and others are CONSTRUCTOR, pick the CLASS
+                resolution = tryAutoResolveClassVsConstructor(resolution);
+                if ("ambiguous".equals(resolution.status())) {
+                    return createAmbiguousResponse("references", resolution);
+                }
             }
             references = resolution.target() != null
                     ? resolver.findReferencesByHandle(resolution.target(), scope, includeDeclaration)
@@ -306,7 +324,10 @@ private JsonNode executeReferences(Path path, JsonNode params) throws IOExceptio
                         resolution);
             }
             if ("ambiguous".equals(resolution.status())) {
-                return createAmbiguousResponse("references", resolution);
+                resolution = tryAutoResolveClassVsConstructor(resolution);
+                if ("ambiguous".equals(resolution.status())) {
+                    return createAmbiguousResponse("references", resolution);
+                }
             }
             references = resolution.target() != null
                     ? resolver.findReferencesByHandle(resolution.target(), scope, includeDeclaration)
@@ -394,7 +415,10 @@ private JsonNode executeHover(Path path, JsonNode params) throws IOException {
         if (symbolName != null && !symbolName.isEmpty()) {
             resolution = resolver.resolveDefinitionByName(path, symbolName);
             if ("ambiguous".equals(resolution.status())) {
-                return createAmbiguousResponse("hover", resolution);
+                resolution = tryAutoResolveClassVsConstructor(resolution);
+                if ("ambiguous".equals(resolution.status())) {
+                    return createAmbiguousResponse("hover", resolution);
+                }
             }
             symbol = resolver.hoverByName(path, symbolName);
         } else if (line > 0) {
@@ -451,17 +475,34 @@ private JsonNode executeHover(Path path, JsonNode params) throws IOException {
 
     /**
      * List Symbols: все символы в файле.
+     * Supports optional filtering by 'kind' and compact output via 'brief'.
      */
-    private JsonNode executeSymbols(Path path) throws IOException {
+    private JsonNode executeSymbols(Path path, JsonNode params) throws IOException {
         List<SymbolInfo> symbols = resolver.listSymbols(path);
 
         if (symbols.isEmpty()) {
             return createTextResponse("No symbols found in " + path.getFileName());
         }
 
+        // Apply kind filter if specified
+        String kindFilter = params.path("kind").asText(null);
+        if (kindFilter != null && !kindFilter.isEmpty()) {
+            symbols = symbols.stream()
+                    .filter(s -> matchesSymbolKind(s.kind(), kindFilter))
+                    .toList();
+            if (symbols.isEmpty()) {
+                return createTextResponse("No " + kindFilter + " symbols found in " + path.getFileName());
+            }
+        }
+
+        boolean brief = params.path("brief").asBoolean(false);
+
         StringBuilder sb = new StringBuilder();
-        sb.append("**Symbols in ").append(path.getFileName()).append("** (")
-                .append(symbols.size()).append(" total)\n\n");
+        sb.append("**Symbols in ").append(path.getFileName()).append("**");
+        if (kindFilter != null) {
+            sb.append(" [kind=").append(kindFilter).append("]");
+        }
+        sb.append(" (").append(symbols.size()).append(" total)\n\n");
 
         // Группируем по типу
         Map<SymbolKind, List<SymbolInfo>> byKind = symbols.stream()
@@ -475,18 +516,23 @@ private JsonNode executeSymbols(Path path) throws IOException {
 
             for (SymbolInfo sym : syms) {
                 Location loc = sym.location();
-                // Регистрируем токен ТОЛЬКО для строки сигнатуры (не для всего файла)
-                String token = registerAccessForRange(path, loc.startLine(), loc.startLine());
-
                 String indent = sym.parentName() != null ? "  " : "";
-                sb.append(indent).append("- `").append(sym.name()).append("`");
-                if (sym.signature() != null) {
-                    sb.append(" — `").append(sym.signature()).append("`");
-                } else if (sym.type() != null) {
-                    sb.append(": ").append(sym.type());
+
+                if (brief) {
+                    // Compact: name + line only
+                    sb.append(indent).append("- `").append(sym.name()).append("` L").append(loc.startLine()).append("\n");
+                } else {
+                    // Full: name + signature/type + line + token
+                    String token = registerAccessForRange(path, loc.startLine(), loc.startLine());
+                    sb.append(indent).append("- `").append(sym.name()).append("`");
+                    if (sym.signature() != null) {
+                        sb.append(" — `").append(sym.signature()).append("`");
+                    } else if (sym.type() != null) {
+                        sb.append(": ").append(sym.type());
+                    }
+                    sb.append(" (line ").append(loc.startLine());
+                    sb.append(" | TOKEN: `").append(token).append("`)\n");
                 }
-                sb.append(" (line ").append(loc.startLine());
-                sb.append(" | TOKEN: `").append(token).append("`)\n");
             }
             sb.append("\n");
         }
@@ -497,6 +543,61 @@ private JsonNode executeSymbols(Path path) throws IOException {
         return createTextResponse(sb.toString());
     }
 
+    /**
+     * Auto-resolves ambiguity when candidates are a CLASS and its CONSTRUCTORs.
+     * In Java/Kotlin, class name and constructor name are identical, causing false ambiguity.
+     * Selects the CLASS candidate since that's what users almost always want.
+     */
+    private ResolutionResult tryAutoResolveClassVsConstructor(ResolutionResult resolution) {
+        if (resolution.candidates() == null || resolution.candidates().size() < 2) {
+            return resolution;
+        }
+
+        SymbolHandle classCandidate = null;
+        boolean allSameNameAndClassOrCtor = true;
+        String firstName = resolution.candidates().get(0).name();
+
+        for (SymbolHandle candidate : resolution.candidates()) {
+            if (!candidate.name().equals(firstName)) {
+                allSameNameAndClassOrCtor = false;
+                break;
+            }
+            SymbolInfo.SymbolKind kind = candidate.kind();
+            if (kind == SymbolInfo.SymbolKind.CLASS || kind == SymbolInfo.SymbolKind.INTERFACE
+                    || kind == SymbolInfo.SymbolKind.ENUM) {
+                classCandidate = candidate;
+            } else if (kind != SymbolInfo.SymbolKind.CONSTRUCTOR) {
+                allSameNameAndClassOrCtor = false;
+                break;
+            }
+        }
+
+        if (allSameNameAndClassOrCtor && classCandidate != null) {
+            return ResolutionResult.exact(classCandidate, "auto_resolved_class_vs_constructor",
+                    resolution.resolutionKind());
+        }
+        return resolution;
+    }
+
+    /**
+     * Checks if a SymbolKind matches the user-specified kind filter string.
+     */
+    private boolean matchesSymbolKind(SymbolKind kind, String filter) {
+        return switch (filter.toLowerCase()) {
+            case "class" -> kind == SymbolKind.CLASS;
+            case "interface" -> kind == SymbolKind.INTERFACE;
+            case "enum" -> kind == SymbolKind.ENUM;
+            case "method" -> kind == SymbolKind.METHOD;
+            case "function" -> kind == SymbolKind.FUNCTION;
+            case "constructor" -> kind == SymbolKind.CONSTRUCTOR;
+            case "field" -> kind == SymbolKind.FIELD;
+            case "variable" -> kind == SymbolKind.VARIABLE;
+            case "constant" -> kind == SymbolKind.CONSTANT;
+            case "property" -> kind == SymbolKind.PROPERTY;
+            default -> true;
+        };
+    }
+
     // ===================== ВСПОМОГАТЕЛЬНЫЕ МЕТОДЫ =====================
 
     /**
@@ -582,7 +683,7 @@ private List<int[]> groupLocationsIntoRanges(List<Location> locations) {
             return Collections.emptyList();
         }
 
-        List<int[]> ranges = new ArrayList<>();
+        List<int[]> ranges = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>();
         int[] current = null;
 
         for (Location loc : locations) {

app/src/main/java/ru/nts/tools/mcp/tools/refactoring/CodeRefactorTool.java

@@ -81,16 +81,21 @@ public String getDescription() {
 
                 GENERATE:
                   path + symbol (class name) + what (accessors|constructor|builder|toString)
+                  Supports options: {overwrite: true} to regenerate existing implementations (e.g., replace old toString).
 
                 LANGUAGES: Java, Kotlin, JS/TS/TSX, Python, Go, Rust, C/C++, C#, PHP, HTML
 
                 EXTRACT_VARIABLE (inverse of inline):
                   path + startLine + variableName [+ endLine] [+ startColumn/endColumn] [+ variableType] [+ replaceAll]
                   Extracts expression into a named variable. Auto-detects type for most languages.
+                  startColumn/endColumn enable sub-line precision for selecting expressions within a line.
                   replaceAll=true (default): replaces ALL identical expressions in the same scope.
                   Example: extract_variable(path='Foo.java', startLine=15, startColumn=20, endColumn=45, variableName='maxRetries')
 
-                OTHER: delete, wrap, extract_method, inline, move, batch
+                INLINE:
+                  Supports keepDeclaration=true to preserve the original variable/method declaration after inlining.
+
+                OTHER: delete, wrap, extract_method, move, batch
 
                 BATCH INTEGRATION:
                 Returns 'affectedFiles' array with access tokens for each modified file.
@@ -132,6 +137,10 @@ public JsonNode getInputSchema() {
         symbol.put("type", "string");
         symbol.put("description", "Symbol name (alternative to line/column). Use 'kind' to disambiguate if multiple matches.");
 
+        // signature (for overload disambiguation)
+        properties.putObject("signature").put("type", "string").put("description",
+            "Method signature for overload disambiguation. Format: '(Type1, Type2)' or '()'. Used with rename/delete to target specific overload.");
+
         // newName (for rename)
         ObjectNode newName = properties.putObject("newName");
         newName.put("type", "string");
@@ -145,7 +154,7 @@ public JsonNode getInputSchema() {
         scopeEnum.add("directory");
         scopeEnum.add("project");
         scope.put("default", "project");
-        scope.put("description", "Scope for reference search (default: project)");
+        scope.put("description", "Scope for reference search (default: project). For rename: 'file', 'directory', or 'project'. For delete: defaults to 'project' when handleReferences is 'comment' or 'remove', otherwise 'file'.");
 
         // kind (optional symbol kind filter)
         ObjectNode kind = properties.putObject("kind");
@@ -178,6 +187,12 @@ public JsonNode getInputSchema() {
         endLine.put("type", "integer");
         endLine.put("description", "End line for range operations");
 
+        // startColumn/endColumn for sub-line precision (extract_variable)
+        properties.putObject("startColumn").put("type", "integer").put("description",
+            "Start column (1-based) for extract_variable. Enables precise sub-line expression selection.");
+        properties.putObject("endColumn").put("type", "integer").put("description",
+            "End column (1-based) for extract_variable. Enables precise sub-line expression selection.");
+
         // what (for generate)
         ObjectNode what = properties.putObject("what");
         what.put("type", "string");
@@ -191,6 +206,8 @@ public JsonNode getInputSchema() {
         whatEnum.add("builder");
         whatEnum.add("equals_hashcode");
         whatEnum.add("toString");
+        whatEnum.add("all_args_constructor");
+        whatEnum.add("no_args_constructor");
         what.put("description", "What to generate (generate operation)");
 
         // fields (for generate)
@@ -216,11 +233,30 @@ public JsonNode getInputSchema() {
         wrapperEnum.add("custom");
         wrapper.put("description", "Wrapper type for wrap operation");
 
+        // template (for wrap with custom wrapper)
+        properties.putObject("template").put("type", "string").put("description",
+            "Custom wrapper template for wrap action with wrapper='custom'. Use ${code} as placeholder for wrapped code.");
+
         // methodName (for extract_method)
         ObjectNode methodName = properties.putObject("methodName");
         methodName.put("type", "string");
         methodName.put("description", "Name for the extracted method");
 
+        // codePattern (for extract_method)
+        ObjectNode codePattern = properties.putObject("codePattern");
+        codePattern.put("type", "string");
+        codePattern.put("description", "For extract_method: regex pattern to find the code block to extract (alternative to startLine/endLine).");
+
+        // accessModifier (for extract_method, change_signature)
+        ObjectNode accessModifier = properties.putObject("accessModifier");
+        accessModifier.put("type", "string");
+        accessModifier.put("description", "For extract_method, change_signature: access modifier for generated method (e.g., 'public', 'private', 'protected').");
+
+        // returnType (for extract_method, change_signature)
+        ObjectNode returnType = properties.putObject("returnType");
+        returnType.put("type", "string");
+        returnType.put("description", "For extract_method, change_signature: return type override.");
+
         // variableName (for extract_variable)
         ObjectNode variableName = properties.putObject("variableName");
         variableName.put("type", "string");
@@ -238,11 +274,25 @@ public JsonNode getInputSchema() {
         replaceAll.put("default", true);
         replaceAll.put("description", "[extract_variable] Replace ALL occurrences of expression in scope (default: true)");
 
+        // keepDeclaration (for inline)
+        properties.putObject("keepDeclaration").put("type", "boolean").put("description",
+            "For inline: keep the original variable/method declaration after inlining usages. Default: false (delete declaration).");
+
         // targetPath (for move)
         ObjectNode targetPath = properties.putObject("targetPath");
         targetPath.put("type", "string");
         targetPath.put("description", "Target file path for move operation");
 
+        // targetClass (for move)
+        ObjectNode targetClass = properties.putObject("targetClass");
+        targetClass.put("type", "string");
+        targetClass.put("description", "For move: target class name (alternative to targetPath for inner-class moves).");
+
+        // position (for move)
+        ObjectNode position = properties.putObject("position");
+        position.put("type", "string");
+        position.put("description", "For move: insertion position in target ('before', 'after', or line number).");
+
         // handleReferences (for delete)
         ObjectNode handleReferences = properties.putObject("handleReferences");
         handleReferences.put("type", "string");
@@ -256,7 +306,7 @@ public JsonNode getInputSchema() {
         // options (generic options object)
         ObjectNode options = properties.putObject("options");
         options.put("type", "object");
-        options.put("description", "Additional options specific to operation");
+        options.put("description", "Additional options. For generate: {\"overwrite\": true} to regenerate existing methods. For wrap: {\"exceptionType\": \"IOException\"}.");
 
         // params (for change_signature)
         ObjectNode csParams = properties.putObject("params");
@@ -286,6 +336,12 @@ public JsonNode getInputSchema() {
         opsItems.put("type", "object");
         operations.put("description", "Array of operations for batch execution");
 
+        // continueOnError (for batch)
+        ObjectNode continueOnError = properties.putObject("continueOnError");
+        continueOnError.put("type", "boolean");
+        continueOnError.put("default", false);
+        continueOnError.put("description", "For batch: continue executing remaining operations if one fails. Default: false.");
+
         // preview
         ObjectNode preview = properties.putObject("preview");
         preview.put("type", "boolean");