@kaluchi/jdtbridge 1.2.0 → 1.3.0

package/README.md

@@ -32,20 +32,20 @@ Run `jdt help <command>` for detailed flags and examples. Most commands have sho
 ```bash
 jdt projects                                           # list workspace projects
 jdt project-info <name> [--lines N]                    # (alias: pi) project overview
-jdt find <Name> [--source-only]                        # find type declarations (* wildcards)
-jdt references <FQN> [method] [--field <name>]         # (alias: refs) references to type/method/field
+jdt find <Name|package> [--source-only]                 # find types by name, wildcard, or package
+jdt references <FQMN> [--field <name>]                  # (alias: refs) references to type/method/field
 jdt subtypes <FQN>                                     # (alias: subt) all subtypes/implementors
 jdt hierarchy <FQN>                                    # (alias: hier) supers + interfaces + subtypes
-jdt implementors <FQN> <method> [--arity N]            # (alias: impl) implementations of interface method
+jdt implementors <FQMN>                                # (alias: impl) implementations of interface method
 jdt type-info <FQN>                                    # (alias: ti) class overview (fields, methods)
-jdt source <FQN> [method] [--arity N]                  # (alias: src) source code (project + libraries)
+jdt source <FQMN>                                      # (alias: src) source code (project + libraries)
 ```
 
 ### Testing & building
 
 ```bash
 jdt build [--project <name>] [--clean]                 # (alias: b) build project
-jdt test <FQN> [method] [--timeout N]                  # run JUnit test class or method
+jdt test <FQMN> [--timeout N]                           # run JUnit test class or method
 jdt test --project <name> [--package <pkg>]            # run tests in project/package
 ```
 
@@ -66,7 +66,7 @@ File paths are workspace-relative: `my-app/src/main/java/.../Foo.java`.
 jdt organize-imports <file>                            # (alias: oi) organize imports
 jdt format <file>                                      # (alias: fmt) format code (Eclipse settings)
 jdt rename <FQN> <newName>                             # rename type
-jdt rename <FQN> <newName> --method <old>              # rename method
+jdt rename <FQMN> <newName>                            # rename method (FQMN includes method)
 jdt rename <FQN> <newName> --field <old>               # rename field
 jdt move <FQN> <target.package>                        # move type to another package
 ```
@@ -75,7 +75,7 @@ jdt move <FQN> <target.package>                        # move type to another pa
 
 ```bash
 jdt active-editor                                      # (alias: ae) current file and cursor line
-jdt open <FQN> [method] [--arity N]                    # open in Eclipse editor
+jdt open <FQMN>                                        # open in Eclipse editor
 ```
 
 ## Instance discovery

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaluchi/jdtbridge",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "CLI for Eclipse JDT Bridge — semantic Java analysis via Eclipse JDT SearchEngine",
   "type": "module",
   "bin": {

package/src/args.mjs

@@ -35,3 +35,73 @@ export function extractPositional(args) {
   }
   return result;
 }
+
+/**
+ * Parse a Fully Qualified Method Name (FQMN) string.
+ *
+ * Supported formats:
+ *   "pkg.Class#method(Type, Type)"  — javadoc / surefire style
+ *   "pkg.Class#method"              — method without signature
+ *   "pkg.Class.method(Type, Type)"  — Eclipse Copy Qualified Name style
+ *   "pkg.Class"                     — plain FQN (no method)
+ *
+ * Returns { className, method, paramTypes } where paramTypes is:
+ *   null  — no signature specified (any overload)
+ *   []    — empty parens, i.e. zero-arg method
+ *   ["String", "int[]", ...] — explicit parameter types
+ */
+export function parseFqmn(input) {
+  if (!input) return { className: null, method: null, paramTypes: null };
+
+  // Javadoc style: Class#method or Class#method(params)
+  const hashIdx = input.indexOf("#");
+  if (hashIdx >= 0) {
+    return parseMethodPart(input.substring(0, hashIdx), input.substring(hashIdx + 1));
+  }
+
+  // Eclipse Copy Qualified Name: only when parentheses are present
+  const parenIdx = input.indexOf("(");
+  if (parenIdx >= 0) {
+    const dotIdx = input.lastIndexOf(".", parenIdx);
+    if (dotIdx >= 0) {
+      return parseMethodPart(input.substring(0, dotIdx), input.substring(dotIdx + 1));
+    }
+  }
+
+  // Plain FQN — no method
+  return { className: input, method: null, paramTypes: null };
+}
+
+function parseMethodPart(className, rest) {
+  const parenIdx = rest.indexOf("(");
+  if (parenIdx < 0) {
+    return { className, method: rest || null, paramTypes: null };
+  }
+
+  const method = rest.substring(0, parenIdx);
+  const closeIdx = rest.lastIndexOf(")");
+  const paramsStr = rest.substring(parenIdx + 1, closeIdx >= 0 ? closeIdx : rest.length);
+
+  if (paramsStr.trim() === "") {
+    return { className, method, paramTypes: [] };
+  }
+
+  return { className, method, paramTypes: splitParams(paramsStr) };
+}
+
+function splitParams(str) {
+  const params = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === "<") depth++;
+    else if (str[i] === ">") depth--;
+    else if (str[i] === "," && depth === 0) {
+      params.push(str.substring(start, i).trim());
+      start = i + 1;
+    }
+  }
+  const last = str.substring(start).trim();
+  if (last) params.push(last);
+  return params;
+}

package/src/cli.mjs

@@ -98,17 +98,17 @@ Requires: Eclipse running with the jdtbridge plugin.
 Search & navigation:
   projects                                    list workspace projects
   project-info${fmtAliases("project-info")} <name> [--lines N]             project overview (adaptive detail)
-  find <Name|*Pattern*> [--source-only]       find type declarations
-  references${fmtAliases("references")} <FQN> [method] [--field <name>]  references to type/method/field
+  find <Name|*Pattern*|pkg> [--source-only]   find types by name, wildcard, or package
+  references${fmtAliases("references")} <FQMN> [--field <name>]         references to type/method/field
   subtypes${fmtAliases("subtypes")} <FQN>                              all subtypes/implementors
   hierarchy${fmtAliases("hierarchy")} <FQN>                             full hierarchy (supers + interfaces + subtypes)
-  implementors${fmtAliases("implementors")} <FQN> <method> [--arity n]     implementations of interface method
+  implementors${fmtAliases("implementors")} <FQMN>                            implementations of interface method
   type-info${fmtAliases("type-info")} <FQN>                             class overview (fields, methods, line numbers)
-  source${fmtAliases("source")} <FQN> [method] [--arity n]           type or method source code (project and libraries)
+  source${fmtAliases("source")} <FQMN>                              type or method source code (project and libraries)
 
 Testing & building:
   build${fmtAliases("build")} [--project <name>] [--clean]      build project (incremental or clean)
-  test <FQN> [method]                         run JUnit test class or method
+  test <FQMN>                                 run JUnit test class or method
   test --project <name> [--package <pkg>]     run tests in project/package
 
 Diagnostics:
@@ -117,12 +117,12 @@ Diagnostics:
 Refactoring:
   organize-imports${fmtAliases("organize-imports")} <file>                     organize imports
   format${fmtAliases("format")} <file>                               format with Eclipse project settings
-  rename <FQN> <newName> [--method|--field]   rename type/method/field
+  rename <FQMN> <newName> [--field <old>]     rename type/method/field
   move <FQN> <target.package>                 move type to another package
 
 Editor:
   active-editor${fmtAliases("active-editor")}                               current file and cursor line
-  open <FQN> [method]                         open in Eclipse editor
+  open <FQMN>                                 open in Eclipse editor
 
 Setup:
   setup [--check|--remove]                    install/check/remove Eclipse plugin

package/src/commands/editor.mjs

@@ -1,5 +1,5 @@
 import { get } from "../client.mjs";
-import { extractPositional, parseFlags } from "../args.mjs";
+import { extractPositional, parseFlags, parseFqmn } from "../args.mjs";
 import { stripProject } from "../paths.mjs";
 
 export async function activeEditor() {
@@ -18,16 +18,18 @@ export async function activeEditor() {
 export async function open(args) {
   const pos = extractPositional(args);
   const flags = parseFlags(args);
-  const fqn = pos[0];
-  const method = pos[1];
+  const parsed = parseFqmn(pos[0]);
+  const fqn = parsed.className;
+  const method = parsed.method || pos[1];
   if (!fqn) {
-    console.error("Usage: open <FQN> [method] [--arity n]");
+    console.error("Usage: open <FQN>[#method[(param types)]]");
     process.exit(1);
   }
   let url = `/open?class=${encodeURIComponent(fqn)}`;
   if (method) url += `&method=${encodeURIComponent(method)}`;
-  if (flags.arity !== undefined && flags.arity !== true)
-    url += `&arity=${flags.arity}`;
+  if (parsed.paramTypes) {
+    url += `&paramTypes=${encodeURIComponent(parsed.paramTypes.join(","))}`;
+  }
   const result = await get(url);
   if (result.error) {
     console.error(result.error);
@@ -42,8 +44,9 @@ Usage:  jdt active-editor`;
 
 export const openHelp = `Open a type or method in the Eclipse editor.
 
-Usage:  jdt open <FQN> [method] [--arity n]
+Usage:  jdt open <FQN>[#method[(param types)]]
 
 Examples:
   jdt open app.m8.dao.StaffDaoImpl
-  jdt open app.m8.dao.StaffDaoImpl getStaff`;
+  jdt open app.m8.dao.StaffDaoImpl#getStaff
+  jdt open "app.m8.dao.StaffDaoImpl#save(Order)"`;

package/src/commands/find.mjs

@@ -25,17 +25,20 @@ export async function find(args) {
   }
 }
 
-export const help = `Find type declarations by name or wildcard pattern.
+export const help = `Find type declarations by name, wildcard, or package.
 
-Usage:  jdt find <Name|*Pattern*> [--source-only]
+Usage:  jdt find <Name|*Pattern*|package.name> [--source-only]
 
 Arguments:
-  Name        exact type name (e.g. DataSourceUtils)
-  *Pattern*   wildcard pattern (e.g. *Controller*, Find*)
+  Name           exact type name (e.g. DataSourceUtils)
+  *Pattern*      wildcard pattern (e.g. *Controller*, Find*)
+  package.name   dotted package name — lists all types in the package
 
 Flags:
   --source-only   exclude binary/library types, show only workspace sources
 
 Examples:
   jdt find DataSourceUtils
-  jdt find *Controller* --source-only`;
+  jdt find *Controller* --source-only
+  jdt find com.example.service
+  jdt find com.example.service.`;

package/src/commands/implementors.mjs

@@ -1,18 +1,21 @@
 import { get } from "../client.mjs";
-import { extractPositional, parseFlags } from "../args.mjs";
+import { extractPositional, parseFlags, parseFqmn } from "../args.mjs";
 import { stripProject } from "../paths.mjs";
 
 export async function implementors(args) {
   const pos = extractPositional(args);
   const flags = parseFlags(args);
-  const [fqn, method] = pos;
+  const parsed = parseFqmn(pos[0]);
+  const fqn = parsed.className;
+  const method = parsed.method || pos[1];
   if (!fqn || !method) {
-    console.error("Usage: implementors <FQN> <method> [--arity n]");
+    console.error("Usage: implementors <FQN>#<method>[(param types)]");
     process.exit(1);
   }
   let url = `/implementors?class=${encodeURIComponent(fqn)}&method=${encodeURIComponent(method)}`;
-  if (flags.arity !== undefined && flags.arity !== true)
-    url += `&arity=${flags.arity}`;
+  if (parsed.paramTypes) {
+    url += `&paramTypes=${encodeURIComponent(parsed.paramTypes.join(","))}`;
+  }
   const results = await get(url, 30_000);
   if (results.error) {
     console.error(results.error);
@@ -29,6 +32,7 @@ export async function implementors(args) {
 
 export const help = `Find implementations of an interface method across all implementing classes.
 
-Usage:  jdt implementors <FQN> <method> [--arity <n>]
+Usage:  jdt implementors <FQN>#<method>[(param types)]
 
-Example:  jdt implementors app.m8.web.shared.core.HasId getId`;
+Examples:
+  jdt implementors app.m8.web.shared.core.HasId#getId`;

package/src/commands/refactoring.mjs

@@ -1,5 +1,5 @@
 import { get } from "../client.mjs";
-import { extractPositional, parseFlags } from "../args.mjs";
+import { extractPositional, parseFlags, parseFqmn } from "../args.mjs";
 import { toWsPath } from "../paths.mjs";
 import { green, yellow } from "../color.mjs";
 
@@ -46,19 +46,21 @@ export async function format(args) {
 export async function rename(args) {
   const pos = extractPositional(args);
   const flags = parseFlags(args);
-  const fqn = pos[0];
+  const parsed = parseFqmn(pos[0]);
+  const fqn = parsed.className;
   const newName = pos[1];
   if (!fqn || !newName) {
     console.error(
-      "Usage: rename <FQN> <newName> [--field name] [--method name] [--arity n]",
+      "Usage: rename <FQN>[#method[(param types)]] <newName> [--field name]",
     );
     process.exit(1);
   }
   let url = `/rename?class=${encodeURIComponent(fqn)}&newName=${encodeURIComponent(newName)}`;
   if (flags.field) url += `&field=${encodeURIComponent(flags.field)}`;
-  if (flags.method) url += `&method=${encodeURIComponent(flags.method)}`;
-  if (flags.arity !== undefined && flags.arity !== true)
-    url += `&arity=${flags.arity}`;
+  if (parsed.method) url += `&method=${encodeURIComponent(parsed.method)}`;
+  if (parsed.paramTypes) {
+    url += `&paramTypes=${encodeURIComponent(parsed.paramTypes.join(","))}`;
+  }
   const result = await get(url, 30_000);
   if (result.error) {
     console.error(result.error);
@@ -103,11 +105,12 @@ Example:  jdt format m8-server/src/main/java/.../Foo.java`;
 
 export const renameHelp = `Rename a type, method, or field (updates all references).
 
-Usage:  jdt rename <FQN> <newName> [--method <old>] [--field <old>] [--arity <n>]
+Usage:  jdt rename <FQN>[#method[(param types)]] <newName>
+        jdt rename <FQN> <newName> [--field <old>]
 
 Examples:
   jdt rename app.m8.dto.Foo Bar
-  jdt rename app.m8.dto.Foo getBar --method getFoo`;
+  jdt rename app.m8.dto.Foo#getFoo getBar`;
 
 export const moveHelp = `Move a type to another package (updates all references).
 

package/src/commands/references.mjs

@@ -1,24 +1,26 @@
 import { get } from "../client.mjs";
-import { extractPositional, parseFlags } from "../args.mjs";
+import { extractPositional, parseFlags, parseFqmn } from "../args.mjs";
 import { formatReferences } from "../format/references.mjs";
 
 export async function references(args) {
   const pos = extractPositional(args);
   const flags = parseFlags(args);
-  const fqn = pos[0];
+  const parsed = parseFqmn(pos[0]);
+  const fqn = parsed.className;
   if (!fqn) {
-    console.error("Usage: references <FQN> [method] [--field name] [--arity n]");
+    console.error("Usage: references <FQN>[#method[(param types)]] [--field name]");
     process.exit(1);
   }
   let url = `/references?class=${encodeURIComponent(fqn)}`;
   if (flags.field) {
     url += `&field=${encodeURIComponent(flags.field)}`;
   } else {
-    const method = pos[1];
+    const method = parsed.method || pos[1];
     if (method) url += `&method=${encodeURIComponent(method)}`;
+    if (parsed.paramTypes) {
+      url += `&paramTypes=${encodeURIComponent(parsed.paramTypes.join(","))}`;
+    }
   }
-  if (flags.arity !== undefined && flags.arity !== true)
-    url += `&arity=${flags.arity}`;
   const results = await get(url, 30_000);
   if (results.error) {
     console.error(results.error);
@@ -33,19 +35,20 @@ export async function references(args) {
 
 export const help = `Find all references to a type, method, or field across the workspace.
 
-Usage:  jdt references <FQN> [method]
+Usage:  jdt references <FQN>[#method[(param types)]]
         jdt references <FQN> --field <name>
-        jdt references <FQN> [method] --arity <n>
 
-Arguments:
-  FQN       fully qualified class name
-  method    method name (optional)
+FQMN formats (Fully Qualified Method Name):
+  pkg.Class#method              any overload
+  pkg.Class#method()            zero-arg overload
+  pkg.Class#method(String)      specific signature
+  pkg.Class.method(String)      Eclipse Copy Qualified Name style
 
 Flags:
   --field <name>   find references to a field
-  --arity <n>      disambiguate overloaded methods by parameter count
 
 Examples:
   jdt references app.m8.dto.web.core.IdOrgRoot
-  jdt references app.m8.dao.StaffDaoImpl getStaff
+  jdt references app.m8.dao.StaffDaoImpl#getStaff
+  jdt references "app.m8.dao.StaffDaoImpl#save(Order)"
   jdt references app.m8.dao.StaffDaoImpl --field staffCache`;

package/src/commands/source.mjs

@@ -1,19 +1,22 @@
 import { getRaw } from "../client.mjs";
-import { extractPositional, parseFlags } from "../args.mjs";
+import { extractPositional, parseFlags, parseFqmn } from "../args.mjs";
 import { stripProject } from "../paths.mjs";
 
 export async function source(args) {
   const pos = extractPositional(args);
   const flags = parseFlags(args);
-  const [fqn, method] = pos;
+  const parsed = parseFqmn(pos[0]);
+  const fqn = parsed.className;
   if (!fqn) {
-    console.error("Usage: source <FQN> [method] [--arity n]");
+    console.error("Usage: source <FQN>[#method[(param types)]]");
     process.exit(1);
   }
+  const method = parsed.method || pos[1];
   let url = `/source?class=${encodeURIComponent(fqn)}`;
   if (method) url += `&method=${encodeURIComponent(method)}`;
-  if (flags.arity !== undefined && flags.arity !== true)
-    url += `&arity=${flags.arity}`;
+  if (parsed.paramTypes) {
+    url += `&paramTypes=${encodeURIComponent(parsed.paramTypes.join(","))}`;
+  }
   const result = await getRaw(url, 30_000);
   const file = result.headers["x-file"] || "?";
   const startLine = result.headers["x-start-line"] || "?";
@@ -35,9 +38,9 @@ export async function source(args) {
 
 export const help = `Print source code of a type or method.
 
-Usage:  jdt source <FQN> [method] [--arity <n>]
+Usage:  jdt source <FQN>[#method[(param types)]]
 
 Examples:
   jdt source app.m8.dao.StaffDaoImpl
-  jdt source app.m8.dao.StaffDaoImpl getStaff
-  jdt source app.m8.dao.StaffDaoImpl save --arity 2`;
+  jdt source app.m8.dao.StaffDaoImpl#getStaff
+  jdt source "app.m8.dao.StaffDaoImpl#save(Order)"`;

package/src/commands/test.mjs

@@ -1,15 +1,16 @@
 import { get } from "../client.mjs";
-import { extractPositional, parseFlags } from "../args.mjs";
+import { extractPositional, parseFlags, parseFqmn } from "../args.mjs";
 import { formatTestResults } from "../format/test-results.mjs";
 
 export async function test(args) {
   const pos = extractPositional(args);
   const flags = parseFlags(args);
   let url = "/test?";
-  const fqn = pos[0];
+  const parsed = parseFqmn(pos[0]);
+  const fqn = parsed.className;
   if (fqn) {
     url += `class=${encodeURIComponent(fqn)}`;
-    const method = pos[1];
+    const method = parsed.method || pos[1];
     if (method) url += `&method=${encodeURIComponent(method)}`;
   } else if (flags.project) {
     url += `project=${encodeURIComponent(flags.project)}`;
@@ -33,7 +34,7 @@ export async function test(args) {
 
 export const help = `Run JUnit tests via Eclipse's built-in test runner.
 
-Usage:  jdt test <FQN> [method]
+Usage:  jdt test <FQN>[#method]
         jdt test --project <name> [--package <pkg>]
 
 Flags:
@@ -43,5 +44,5 @@ Flags:
 
 Examples:
   jdt test app.m8ws.utils.ObjectMapperTest
-  jdt test app.m8ws.utils.ObjectMapperTest testSerialize
+  jdt test app.m8ws.utils.ObjectMapperTest#testSerialize
   jdt test --project m8-server`;