Bump version to 4.2.5.1, upgrade dependencies

- Upgrade transformer-api 4.2.4→4.2.5, sqlite-jdbc 3.53.0.0→3.53.1.0,
  dex-tools 2.4.35→2.4.36
- Across-archive CHA virtual call resolution (outgoing + incoming)
- Human-readable method signatures in JSON and tree output
- Tree-formatted text output (├──/└──) for call chains
- Independent callers/callees node budgets
- AtomicInteger → plain int[] in graph traversal tools
- Fix eligible neighbor list overflow bug

Author: AgeloVito

pom.xml

@@ -7,7 +7,7 @@
 
     <groupId>io.github.agelovito</groupId>
     <artifactId>jd-mcp-duo</artifactId>
-    <version>4.2.4.1</version>
+    <version>4.2.5.1</version>
     <packaging>jar</packaging>
 
     <name>JD MCP Duo</name>
@@ -30,7 +30,7 @@
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <gson.version>2.14.0</gson.version>
         <slf4j.version>2.0.17</slf4j.version>
-        <transformer-api.version>4.2.4</transformer-api.version>
+        <transformer-api.version>4.2.5</transformer-api.version>
     </properties>
 
 
@@ -81,12 +81,12 @@
         <dependency>
             <groupId>org.xerial</groupId>
             <artifactId>sqlite-jdbc</artifactId>
-            <version>3.53.0.0</version>
+            <version>3.53.1.0</version>
         </dependency>
         <dependency>
             <groupId>de.femtopedia.dex2jar</groupId>
             <artifactId>dex-tools</artifactId>
-            <version>2.4.35</version>
+            <version>2.4.36</version>
         </dependency>
 
         <!-- Test dependencies -->

src/main/java/sqlite/PersistentScopeIndex.java

@@ -287,11 +287,68 @@ WHERE archive_path IN (%s) AND target_owner = ? AND target_name = ? AND target_d
                             new MethodRef(rs.getString("source_owner"), rs.getString("source_name"), rs.getString("source_desc"))
                     ));
                 }
+                results.addAll(expandVirtualCallers(connection, target));
                 return results;
             }
         }
     }
 
+    private Set<ScopedMethodRef> expandVirtualCallers(Connection connection, MethodRef target) throws Exception {
+        String parentSql = """
+                SELECT DISTINCT parent
+                FROM (
+                    SELECT i.interface_name AS parent
+                    FROM interfaces i
+                    WHERE i.archive_path IN (%1$s) AND i.owner = ?
+                    UNION
+                    SELECT c.super_name AS parent
+                    FROM classes c
+                    WHERE c.archive_path IN (%1$s) AND c.internal_name = ? AND c.super_name IS NOT NULL
+                )
+                WHERE parent IS NOT NULL
+                """.formatted(placeholders(scopePaths.size()));
+        Set<String> parentOwners = new LinkedHashSet<>();
+        try (PreparedStatement statement = connection.prepareStatement(parentSql)) {
+            int index = bindPaths(statement, 1);
+            statement.setString(index++, target.owner());
+            statement.setString(index, target.owner());
+            try (ResultSet rs = statement.executeQuery()) {
+                while (rs.next()) {
+                    parentOwners.add(rs.getString("parent"));
+                }
+            }
+        }
+
+        if (parentOwners.isEmpty()) {
+            return Set.of();
+        }
+
+        Set<ScopedMethodRef> results = new LinkedHashSet<>();
+        String callerSql = """
+                SELECT archive_path, source_owner, source_name, source_desc
+                FROM calls
+                WHERE archive_path IN (%s) AND target_owner = ? AND target_name = ? AND target_desc = ?
+                ORDER BY archive_path, source_owner, source_name, source_desc
+                """.formatted(placeholders(scopePaths.size()));
+        try (PreparedStatement statement = connection.prepareStatement(callerSql)) {
+            for (String parent : parentOwners) {
+                int index = bindPaths(statement, 1);
+                statement.setString(index++, parent);
+                statement.setString(index++, target.name());
+                statement.setString(index, target.descriptor());
+                try (ResultSet rs = statement.executeQuery()) {
+                    while (rs.next()) {
+                        results.add(new ScopedMethodRef(
+                                Path.of(rs.getString("archive_path")),
+                                new MethodRef(rs.getString("source_owner"), rs.getString("source_name"), rs.getString("source_desc"))
+                        ));
+                    }
+                }
+            }
+        }
+        return results;
+    }
+
     public Set<ScopedMethodRef> outgoingScoped(MethodRef source) throws Exception {
         String sql = """
                 SELECT archive_path, target_owner, target_name, target_desc
@@ -305,12 +362,45 @@ WHERE archive_path IN (%s) AND source_owner = ? AND source_name = ? AND source_d
             statement.setString(index++, source.owner());
             statement.setString(index++, source.name());
             statement.setString(index, source.descriptor());
+            try (ResultSet rs = statement.executeQuery()) {
+                Set<ScopedMethodRef> results = new LinkedHashSet<>();
+                while (rs.next()) {
+                    MethodRef callee = new MethodRef(rs.getString("target_owner"), rs.getString("target_name"), rs.getString("target_desc"));
+                    results.add(new ScopedMethodRef(Path.of(rs.getString("archive_path")), callee));
+                    results.addAll(expandVirtualTargets(connection, callee));
+                }
+                return results;
+            }
+        }
+    }
+
+    private Set<ScopedMethodRef> expandVirtualTargets(Connection connection, MethodRef target) throws Exception {
+        String sql = """
+                SELECT m.archive_path, m.owner, m.name, m.descriptor
+                FROM methods m
+                WHERE m.archive_path IN (%s)
+                  AND m.name = ? AND m.descriptor = ?
+                  AND m.owner IN (
+                    SELECT DISTINCT c.internal_name
+                    FROM classes c
+                    LEFT JOIN interfaces i ON i.archive_path = c.archive_path AND i.owner = c.internal_name
+                    WHERE c.archive_path IN (%1$s)
+                      AND (c.super_name = ? OR i.interface_name = ?)
+                  )
+                ORDER BY m.archive_path, m.owner
+                """.formatted(placeholders(scopePaths.size()));
+        try (PreparedStatement statement = connection.prepareStatement(sql)) {
+            int index = bindPaths(statement, 1);
+            statement.setString(index++, target.name());
+            statement.setString(index++, target.descriptor());
+            statement.setString(index++, target.owner());
+            statement.setString(index, target.owner());
             try (ResultSet rs = statement.executeQuery()) {
                 Set<ScopedMethodRef> results = new LinkedHashSet<>();
                 while (rs.next()) {
                     results.add(new ScopedMethodRef(
                             Path.of(rs.getString("archive_path")),
-                            new MethodRef(rs.getString("target_owner"), rs.getString("target_name"), rs.getString("target_desc"))
+                            new MethodRef(rs.getString("owner"), rs.getString("name"), rs.getString("descriptor"))
                     ));
                 }
                 return results;

src/main/java/support/GraphSupport.java

@@ -4,7 +4,6 @@
 import com.google.gson.JsonObject;
 
 import java.util.Set;
-import java.util.concurrent.atomic.AtomicInteger;
 
 public final class GraphSupport {
     private GraphSupport() {
@@ -19,13 +18,13 @@ public static JsonObject graphMeta(String direction, int depth, int maxNodes) {
         return json;
     }
 
-    public static boolean consumeNode(AtomicInteger remaining, JsonObject rootMeta, JsonObject node) {
-        if (remaining.get() <= 0) {
+    public static boolean consumeNode(int[] remaining, JsonObject rootMeta, JsonObject node) {
+        if (remaining[0] <= 0) {
             node.addProperty("truncated", true);
             rootMeta.addProperty("truncated", true);
             return false;
         }
-        remaining.decrementAndGet();
+        remaining[0]--;
         return true;
     }
 

src/main/java/tools/CallChainTool.java

@@ -18,7 +18,6 @@
 import java.util.Deque;
 import java.util.HashSet;
 import java.util.Set;
-import java.util.concurrent.atomic.AtomicInteger;
 
 public class CallChainTool implements MCPTool {
     @Override
@@ -60,6 +59,8 @@ public ToolResult execute(JsonObject arguments) throws Exception {
         String direction = normalizeDirection(JsonUtils.getString(arguments, "direction", "both"));
         int depth = JsonUtils.getInt(arguments, "depth", 3);
         int maxNodes = JsonUtils.getInt(arguments, "maxNodes", 128);
+        if (depth < 1) depth = 1;
+        if (maxNodes < 1) maxNodes = 1;
 
         var candidates = index.resolveMethodCandidates(owner, methodName, descriptor);
         var broadCandidates = (descriptor != null && !descriptor.isBlank()) ? index.resolveMethodCandidates(owner, methodName, null) : candidates;
@@ -74,7 +75,6 @@ public ToolResult execute(JsonObject arguments) throws Exception {
         }
 
         ScopedMethodRef root = new ScopedMethodRef(candidates.get(0).sourcePath(), candidates.get(0).indexedMethod().ref());
-        AtomicInteger remaining = new AtomicInteger(Math.max(1, maxNodes));
         JsonObject structured = GraphSupport.graphMeta(direction, depth, maxNodes);
         structured.addProperty("resolved", true);
         structured.addProperty("indexBackend", "sqlite");
@@ -84,16 +84,18 @@ public ToolResult execute(JsonObject arguments) throws Exception {
         structured.add("root", methodJson(root));
 
         StringBuilder text = new StringBuilder();
-        text.append("Call chain for ").append(root.methodRef().displayName()).append(" @ ").append(root.sourcePath()).append('\n');
+        text.append("Call chain for ").append(humanSignature(root.methodRef())).append(" @ ").append(root.sourcePath()).append('\n');
 
         if ("callers".equals(direction) || "both".equals(direction)) {
             text.append("\nCallers:\n");
-            JsonObject callersTree = buildTreeBfs(index, root, true, depth, remaining, new HashSet<>(), structured, text);
+            int[] callerBudget = {maxNodes};
+            JsonObject callersTree = buildTreeBfs(index, root, true, depth, callerBudget, new HashSet<>(), structured, text);
             structured.add("callers", callersTree);
         }
         if ("callees".equals(direction) || "both".equals(direction)) {
             text.append("\nCallees:\n");
-            JsonObject calleesTree = buildTreeBfs(index, root, false, depth, remaining, new HashSet<>(), structured, text);
+            int[] calleeBudget = {maxNodes};
+            JsonObject calleesTree = buildTreeBfs(index, root, false, depth, calleeBudget, new HashSet<>(), structured, text);
             structured.add("callees", calleesTree);
         }
         structured.addProperty("queryMillis", (System.nanoTime() - startedAt) / 1_000_000L);
@@ -105,7 +107,7 @@ private static JsonObject buildTreeBfs(PersistentScopeIndex index,
                                             ScopedMethodRef root,
                                             boolean reverse,
                                             int depth,
-                                            AtomicInteger remaining,
+                                            int[] remaining,
                                             Set<ScopedMethodRef> visited,
                                             JsonObject graphMeta,
                                             StringBuilder text) throws Exception {
@@ -114,14 +116,14 @@ private static JsonObject buildTreeBfs(PersistentScopeIndex index,
             return rootNode;
         }
         rootNode.add("children", new JsonArray());
-        text.append("- ").append(root.methodRef().displayName()).append(" @ ").append(root.sourcePath()).append('\n');
+        text.append(humanSignature(root.methodRef())).append(" @ ").append(root.sourcePath()).append('\n');
 
-        record BfsFrame(ScopedMethodRef method, JsonObject parentNode, int currentDepth) {}
+        record BfsFrame(ScopedMethodRef method, JsonObject parentNode, int currentDepth, String prefix) {}
         Deque<BfsFrame> queue = new ArrayDeque<>();
-        queue.addLast(new BfsFrame(root, rootNode, 0));
+        queue.addLast(new BfsFrame(root, rootNode, 0, ""));
         visited.add(root);
 
-        while (!queue.isEmpty() && remaining.get() > 0 && depth > 0) {
+        while (!queue.isEmpty() && remaining[0] > 0) {
             BfsFrame frame = queue.removeFirst();
             if (frame.currentDepth() >= depth) {
                 continue;
@@ -131,14 +133,19 @@ record BfsFrame(ScopedMethodRef method, JsonObject parentNode, int currentDepth)
                     ? index.incomingScoped(frame.method().methodRef())
                     : index.outgoingScoped(frame.method().methodRef());
 
-            for (ScopedMethodRef neighbor : neighbors) {
-                if (remaining.get() <= 0) {
+            var eligible = new java.util.ArrayList<ScopedMethodRef>();
+            for (ScopedMethodRef n : neighbors) {
+                if (remaining[0] <= 0) break;
+                if (!visited.contains(n)) eligible.add(n);
+            }
+
+            for (int idx = 0; idx < eligible.size(); idx++) {
+                if (remaining[0] <= 0) {
                     graphMeta.addProperty("truncated", true);
                     break;
                 }
-                if (visited.contains(neighbor)) {
-                    continue;
-                }
+                ScopedMethodRef neighbor = eligible.get(idx);
+                boolean last = (idx == eligible.size() - 1);
                 visited.add(neighbor);
 
                 JsonObject childNode = methodJson(neighbor);
@@ -148,17 +155,20 @@ record BfsFrame(ScopedMethodRef method, JsonObject parentNode, int currentDepth)
                 }
                 childNode.add("children", new JsonArray());
                 frame.parentNode().getAsJsonArray("children").add(childNode);
-                text.append("  ".repeat(frame.currentDepth() + 1))
-                        .append("- ").append(neighbor.methodRef().displayName())
+
+                String branch = last ? "└── " : "├── ";
+                text.append(frame.prefix()).append(branch)
+                        .append(humanSignature(neighbor.methodRef()))
                         .append(" @ ").append(neighbor.sourcePath()).append('\n');
 
                 if (frame.currentDepth() + 1 < depth) {
-                    queue.addLast(new BfsFrame(neighbor, childNode, frame.currentDepth() + 1));
+                    String childPrefix = frame.prefix() + (last ? "    " : "│   ");
+                    queue.addLast(new BfsFrame(neighbor, childNode, frame.currentDepth() + 1, childPrefix));
                 }
             }
         }
 
-        if (remaining.get() <= 0) {
+        if (remaining[0] <= 0) {
             graphMeta.addProperty("truncated", true);
         }
         return rootNode;
@@ -172,10 +182,67 @@ private static JsonObject methodJson(ScopedMethodRef scopedMethod) {
         json.addProperty("displayOwner", method.owner().replace('/', '.'));
         json.addProperty("name", method.name());
         json.addProperty("descriptor", method.descriptor());
+        var sig = formatSignature(method.descriptor());
+        json.addProperty("params", sig.params());
+        json.addProperty("returnType", sig.returnType());
+        json.addProperty("signature", sig.params() + ": " + sig.returnType());
         json.addProperty("displayName", method.displayName());
         return json;
     }
 
+    private static String humanSignature(MethodRef method) {
+        var sig = formatSignature(method.descriptor());
+        return method.owner().replace('/', '.') + "." + method.name() + sig.params() + ": " + sig.returnType();
+    }
+
+    private record MethodSignature(String params, String returnType) {}
+
+    private static MethodSignature formatSignature(String descriptor) {
+        int end = descriptor.indexOf(')');
+        if (end < 0) return new MethodSignature("()", "void");
+        StringBuilder params = new StringBuilder("(");
+        int i = 1;
+        while (i < end) {
+            if (params.length() > 1) params.append(", ");
+            i = appendTypeName(descriptor, i, params);
+        }
+        params.append(')');
+        StringBuilder ret = new StringBuilder();
+        if (end + 1 < descriptor.length()) {
+            appendTypeName(descriptor, end + 1, ret);
+        } else {
+            ret.append("void");
+        }
+        return new MethodSignature(params.toString(), ret.toString());
+    }
+
+    private static int appendTypeName(String descriptor, int pos, StringBuilder sb) {
+        char ch = descriptor.charAt(pos);
+        return switch (ch) {
+            case 'B' -> { sb.append("byte");    yield pos + 1; }
+            case 'C' -> { sb.append("char");    yield pos + 1; }
+            case 'D' -> { sb.append("double");  yield pos + 1; }
+            case 'F' -> { sb.append("float");   yield pos + 1; }
+            case 'I' -> { sb.append("int");     yield pos + 1; }
+            case 'J' -> { sb.append("long");    yield pos + 1; }
+            case 'S' -> { sb.append("short");   yield pos + 1; }
+            case 'Z' -> { sb.append("boolean"); yield pos + 1; }
+            case 'V' -> { sb.append("void");    yield pos + 1; }
+            case 'L' -> {
+                int end = descriptor.indexOf(';', pos);
+                String full = descriptor.substring(pos + 1, end);
+                sb.append(full.substring(full.lastIndexOf('/') + 1));
+                yield end + 1;
+            }
+            case '[' -> {
+                int nextPos = appendTypeName(descriptor, pos + 1, sb);
+                sb.append("[]");
+                yield nextPos;
+            }
+            default -> pos + 1;
+        };
+    }
+
     private static String normalizeDirection(String direction) {
         String normalized = direction == null ? "both" : direction.trim().toLowerCase();
         return switch (normalized) {