@kaluchi/jdtbridge 1.2.0 → 1.4.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,16 +66,32 @@ 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
 ```
 
+### Launches
+
+```bash
+jdt launch list                                        # list launches (running + terminated)
+jdt launch configs                                     # list saved launch configurations
+jdt launch run <config> [-f] [-q]                      # launch a configuration
+jdt launch debug <config> [-f] [-q]                    # launch in debug mode
+jdt launch logs <name> [-f] [--tail N]                 # show console output
+jdt launch stop <name>                                 # stop a running launch
+jdt launch clear [name]                                # remove terminated launches
+```
+
+`-f` streams output in real-time until the process terminates.
+Without `-f`, `launch run` prints an onboarding guide with available commands (`-q` to suppress).
+Console output persists in Eclipse and is available via `launch logs` at any time.
+
 ### Editor
 
 ```bash
-jdt active-editor                                      # (alias: ae) current file and cursor line
-jdt open <FQN> [method] [--arity N]                    # open in Eclipse editor
+jdt editors                                             # (alias: ed) list all open editors (absolute paths)
+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.4.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

@@ -24,11 +24,29 @@ import {
   moveHelp,
 } from "./commands/refactoring.mjs";
 import {
-  activeEditor,
+  editors,
   open,
-  activeEditorHelp,
+  editorsHelp,
   openHelp,
 } from "./commands/editor.mjs";
+import {
+  launchList,
+  launchConfigs,
+  launchRun,
+  launchDebug,
+  launchStop,
+  launchClear,
+  launchLogs,
+  launchConsole,
+  launchListHelp,
+  launchConfigsHelp,
+  launchRunHelp,
+  launchDebugHelp,
+  launchStopHelp,
+  launchClearHelp,
+  launchLogsHelp,
+  launchConsoleHelp,
+} from "./commands/launch.mjs";
 import { setup, help as setupHelp } from "./commands/setup.mjs";
 import { isConnectionError } from "./client.mjs";
 import { bold, red, dim } from "./color.mjs";
@@ -36,6 +54,45 @@ import { createRequire } from "node:module";
 
 const { version } = createRequire(import.meta.url)("../package.json");
 
+const launchSubcommands = {
+  list: { fn: launchList, help: launchListHelp },
+  configs: { fn: launchConfigs, help: launchConfigsHelp },
+  run: { fn: launchRun, help: launchRunHelp },
+  debug: { fn: launchDebug, help: launchDebugHelp },
+  stop: { fn: launchStop, help: launchStopHelp },
+  clear: { fn: launchClear, help: launchClearHelp },
+  logs: { fn: launchLogs, help: launchLogsHelp },
+  console: { fn: launchConsole, help: launchConsoleHelp },
+};
+
+const launchHelp = `Manage launches (running and terminated processes).
+
+Subcommands:
+  jdt launch list                           list all launches
+  jdt launch configs                        list saved launch configurations
+  jdt launch run <config> [-f] [-q]         launch a configuration
+  jdt launch debug <config> [-f] [-q]       launch in debug mode
+  jdt launch logs <name> [-f] [--tail N]    show console output
+  jdt launch stop <name>                    stop a running launch
+  jdt launch clear [name]                   remove terminated launches
+
+Use "jdt help launch <subcommand>" for details.`;
+
+async function launchDispatch(args) {
+  const [sub, ...rest] = args;
+  if (!sub || sub === "--help") {
+    console.log(launchHelp);
+    return;
+  }
+  const cmd = launchSubcommands[sub];
+  if (!cmd) {
+    console.error(`Unknown launch subcommand: ${sub}`);
+    console.log(launchHelp);
+    process.exit(1);
+  }
+  await cmd.fn(rest);
+}
+
 const commands = {
   projects: { fn: projects, help: projectsHelp },
   "project-info": { fn: projectInfo, help: projectInfoHelp },
@@ -53,8 +110,9 @@ const commands = {
   format: { fn: format, help: formatHelp },
   rename: { fn: rename, help: renameHelp },
   move: { fn: move, help: moveHelp },
-  "active-editor": { fn: activeEditor, help: activeEditorHelp },
+  editors: { fn: editors, help: editorsHelp },
   open: { fn: open, help: openHelp },
+  launch: { fn: launchDispatch, help: launchHelp },
   setup: { fn: setup, help: setupHelp },
 };
 
@@ -67,7 +125,7 @@ const aliases = {
   pi: "project-info",
   ti: "type-info",
   oi: "organize-imports",
-  ae: "active-editor",
+  ed: "editors",
   src: "source",
   b: "build",
   err: "errors",
@@ -98,17 +156,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 +175,21 @@ 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
 
+Launches:
+  launch list                                 list launches (running + terminated)
+  launch configs                              list saved launch configurations
+  launch run <config> [-f] [-q]               launch a configuration
+  launch debug <config> [-f] [-q]             launch in debug mode
+  launch logs <name> [-f] [--tail N]          show console output
+  launch stop <name>                          stop a running launch
+  launch clear [name]                         remove terminated launches
+
 Editor:
-  active-editor${fmtAliases("active-editor")}                               current file and cursor line
-  open <FQN> [method]                         open in Eclipse editor
+  editors${fmtAliases("editors")}                                    list open editors (absolute paths)
+  open <FQMN>                                 open in Eclipse editor
 
 Setup:
   setup [--check|--remove]                    install/check/remove Eclipse plugin
@@ -146,7 +213,9 @@ export async function run(argv) {
   if (command === "help") {
     const topic = rest[0];
     const resolved = topic ? resolve(topic) : null;
-    if (resolved) {
+    if (resolved === "launch" && rest[1] && launchSubcommands[rest[1]]) {
+      console.log(launchSubcommands[rest[1]].help);
+    } else if (resolved) {
       console.log(commands[resolved].help);
     } else if (topic) {
       console.error(`Unknown command: ${topic}`);

package/src/client.mjs

@@ -158,6 +158,44 @@ export function getRaw(path, timeoutMs = 10_000) {
   });
 }
 
+/**
+ * HTTP GET with streaming response. Pipes text/plain chunks to
+ * the provided writable stream (typically process.stdout).
+ * Resolves when the server closes the connection.
+ * Rejects on non-200 status or connection error.
+ * @param {string} path
+ * @param {import('stream').Writable} dest
+ * @returns {Promise<void>}
+ */
+export function getStream(path, dest) {
+  const inst = connect();
+  return new Promise((resolve, reject) => {
+    const req = request(
+      {
+        hostname: "127.0.0.1",
+        port: inst.port,
+        path,
+        method: "GET",
+        timeout: 0, // no timeout for streaming
+        headers: authHeaders(),
+      },
+      (res) => {
+        if (res.statusCode !== 200) {
+          let data = "";
+          res.on("data", (chunk) => (data += chunk));
+          res.on("end", () => reject(new Error(data.trim())));
+          return;
+        }
+        res.pipe(dest, { end: false });
+        res.on("end", resolve);
+        res.on("error", reject);
+      },
+    );
+    req.on("error", reject);
+    req.end();
+  });
+}
+
 /**
  * Check if error is a connection refused error.
  * @param {Error} e

package/src/commands/editor.mjs

@@ -1,33 +1,36 @@
 import { get } from "../client.mjs";
-import { extractPositional, parseFlags } from "../args.mjs";
-import { stripProject } from "../paths.mjs";
+import { extractPositional, parseFlags, parseFqmn } from "../args.mjs";
 
-export async function activeEditor() {
-  const result = await get("/active-editor");
-  if (result.error) {
-    console.error(result.error);
+export async function editors() {
+  const results = await get("/editors");
+  if (results.error) {
+    console.error(results.error);
     process.exit(1);
   }
-  if (result.file === null) {
-    console.log("(no file open)");
-  } else {
-    console.log(`${stripProject(result.file)}:${result.line}`);
+  if (results.length === 0) {
+    console.log("(no open editors)");
+    return;
+  }
+  for (const r of results) {
+    console.log(r.file);
   }
 }
 
 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);
@@ -36,14 +39,17 @@ export async function open(args) {
   console.log("Opened");
 }
 
-export const activeEditorHelp = `Show the file and cursor line of the active Eclipse editor.
+export const editorsHelp = `List all open editors in Eclipse. Active editor first.
+
+Usage:  jdt editors
 
-Usage:  jdt active-editor`;
+Output: absolute file paths, one per line.`;
 
 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/launch.mjs

@@ -0,0 +1,308 @@
+import { get, getStream } from "../client.mjs";
+import { extractPositional, parseFlags } from "../args.mjs";
+
+export async function launchList() {
+  const results = await get("/launch/list");
+  if (results.error) {
+    console.error(results.error);
+    process.exit(1);
+  }
+  if (results.length === 0) {
+    console.log("(no launches)");
+    return;
+  }
+  for (const r of results) {
+    const status = r.terminated
+      ? `terminated${r.exitCode !== undefined ? ` (${r.exitCode})` : ""}`
+      : "running";
+    const parts = [r.name, r.type, r.mode, status];
+    if (r.pid) parts.push(`pid:${r.pid}`);
+    console.log(parts.join("  "));
+  }
+}
+
+export async function launchConfigs() {
+  const results = await get("/launch/configs");
+  if (results.error) {
+    console.error(results.error);
+    process.exit(1);
+  }
+  if (results.length === 0) {
+    console.log("(no launch configurations)");
+    return;
+  }
+  for (const r of results) {
+    console.log(`${r.name}  ${r.type}`);
+  }
+}
+
+export async function launchClear(args) {
+  const pos = extractPositional(args);
+  let url = "/launch/clear";
+  if (pos[0]) url += `?name=${encodeURIComponent(pos[0])}`;
+  const result = await get(url);
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  console.log(`Removed ${result.removed} terminated launch${result.removed !== 1 ? "es" : ""}`);
+}
+
+/**
+ * Launch a configuration. Without -f, prints onboarding guide.
+ * With -f, streams console output until termination.
+ */
+export async function launchRun(args) {
+  return launchWithMode(args, "run");
+}
+
+/** Launch in debug mode. Same interface as run. */
+export async function launchDebug(args) {
+  return launchWithMode(args, "debug");
+}
+
+async function launchWithMode(args, mode) {
+  const pos = extractPositional(args);
+  const name = pos[0];
+  if (!name) {
+    console.error(`Usage: launch ${mode} <config-name> [-f] [-q]`);
+    process.exit(1);
+  }
+
+  let url = `/launch/run?name=${encodeURIComponent(name)}`;
+  if (mode === "debug") url += "&debug";
+  const result = await get(url, 30_000);
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+
+  const follow = args.includes("-f") || args.includes("--follow");
+  if (follow) {
+    console.error(formatLaunched(result));
+    const exitCode = await followLogs(result.name, args);
+    process.exit(exitCode);
+  }
+
+  const quiet = args.includes("-q") || args.includes("--quiet");
+  const n = result.name;
+  console.log(formatLaunched(result));
+
+  if (!quiet) {
+    console.log(launchGuide(n));
+  }
+}
+
+function formatLaunched(result) {
+  const parts = [`Launched ${result.name} (${result.mode})`];
+  if (result.type) parts[0] += ` [${result.type}]`;
+  if (result.pid) parts.push(`  PID:        ${result.pid}`);
+  if (result.workingDir) parts.push(`  Working dir: ${result.workingDir}`);
+  if (result.cmdline) {
+    parts.push(`  Command:    ${result.cmdline}`);
+  }
+  return parts.join("\n");
+}
+
+function launchGuide(name) {
+  return `
+  Console output is captured by Eclipse and remains available
+  after the process terminates. You can read it at any time,
+  filter with grep, or pipe through tail/head.
+
+  View logs:
+    jdt launch logs ${name}
+    jdt launch logs ${name} --tail 30
+
+  Wait for completion (blocks until process exits):
+    jdt launch logs ${name} -f | tail -20
+    jdt launch logs ${name} -f
+
+  Manage:
+    jdt launch list
+    jdt launch stop ${name}
+    jdt launch clear
+
+  Run modes:
+    jdt launch run <config>           launch (this output)
+    jdt launch run <config> -f        launch + stream output
+    jdt launch run <config> -f | tail launch + wait + bounded
+    jdt launch debug <config>         launch with debugger
+
+  Add -q to suppress this guide.`;
+}
+
+export async function launchStop(args) {
+  const pos = extractPositional(args);
+  const name = pos[0];
+  if (!name) {
+    console.error("Usage: launch stop <name>");
+    process.exit(1);
+  }
+  const url = `/launch/stop?name=${encodeURIComponent(name)}`;
+  const result = await get(url);
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  console.log(`Stopped ${result.name}`);
+}
+
+/**
+ * Show console output. "logs" is the primary name,
+ * "console" is kept as an alias.
+ */
+export async function launchLogs(args) {
+  const pos = extractPositional(args);
+  const flags = parseFlags(args);
+  const name = pos[0];
+  if (!name) {
+    console.error(
+      "Usage: launch logs <name> [-f|--follow] [--tail N]",
+    );
+    process.exit(1);
+  }
+
+  const follow = args.includes("-f") || args.includes("--follow");
+  if (follow) {
+    const exitCode = await followLogs(name, args);
+    process.exit(exitCode);
+  }
+
+  // Snapshot mode
+  let url = `/launch/console?name=${encodeURIComponent(name)}`;
+  if (flags.tail !== undefined && flags.tail !== true)
+    url += `&tail=${flags.tail}`;
+  if (args.includes("--stderr")) url += "&stream=stderr";
+  else if (args.includes("--stdout")) url += "&stream=stdout";
+  const result = await get(url, 30_000);
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  if (result.output) {
+    const text = result.output.endsWith("\n")
+      ? result.output.slice(0, -1)
+      : result.output;
+    console.log(text);
+  }
+}
+
+/** Alias: console → logs */
+export const launchConsole = launchLogs;
+
+/**
+ * Stream console output until process terminates or Ctrl+C.
+ * Returns the process exit code (0 on detach).
+ */
+async function followLogs(name, args) {
+  const flags = parseFlags(args);
+  let url = `/launch/console/stream?name=${encodeURIComponent(name)}`;
+  if (flags.tail !== undefined && flags.tail !== true)
+    url += `&tail=${flags.tail}`;
+  if (args.includes("--stderr")) url += "&stream=stderr";
+  else if (args.includes("--stdout")) url += "&stream=stdout";
+
+  // Ctrl+C = detach, not kill
+  let detached = false;
+  const onSigint = () => {
+    detached = true;
+    process.stdout.write("\n");
+    process.exit(0);
+  };
+  process.on("SIGINT", onSigint);
+
+  try {
+    await getStream(url, process.stdout);
+  } catch (e) {
+    if (!detached) {
+      console.error(e.message);
+      return 1;
+    }
+    return 0;
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+  }
+
+  // Stream ended — fetch exit code
+  try {
+    const list = await get("/launch/list");
+    const entry = Array.isArray(list)
+      ? list.find((l) => l.name === name && l.terminated)
+      : null;
+    return entry?.exitCode ?? 0;
+  } catch {
+    return 0;
+  }
+}
+
+export const launchRunHelp = `Launch a saved configuration.
+
+Usage:  jdt launch run <config-name> [-f] [-q]
+
+Without -f, launches and prints a guide with available commands.
+With -f, launches and streams console output until the process terminates.
+
+Flags:
+  -f, --follow   stream output (Ctrl+C to detach, process keeps running)
+  -q, --quiet    suppress onboarding guide
+
+Examples:
+  jdt launch run m8-server                run + show guide
+  jdt launch run m8-server -q             run silently
+  jdt launch run jdtbridge-verify -f      run + stream all output
+  jdt launch run m8-server -f | tail -20  run + wait + bounded output`;
+
+export const launchDebugHelp = `Launch a configuration in debug mode.
+
+Usage:  jdt launch debug <config-name> [-f] [-q]
+
+Same as "launch run" but attaches the Eclipse debugger.
+
+Examples:
+  jdt launch debug m8-server
+  jdt launch debug m8-server -f`;
+
+export const launchStopHelp = `Stop a running launch.
+
+Usage:  jdt launch stop <name>
+
+Example:  jdt launch stop m8-server`;
+
+export const launchConfigsHelp = `List saved launch configurations (Run → Run Configurations).
+
+Usage:  jdt launch configs
+
+Output: configuration name and type, one per line.`;
+
+export const launchClearHelp = `Remove terminated launches and their console output.
+
+Usage:  jdt launch clear [name]
+
+Without name, removes all terminated launches. With name, removes only that one.`;
+
+export const launchListHelp = `List all launches (running and terminated).
+
+Usage:  jdt launch list
+
+Output: name, type, mode, status — one launch per line.`;
+
+export const launchLogsHelp = `Show console output of a launch.
+
+Console output is captured by Eclipse and persists after the process
+terminates. Without -f, returns a snapshot. With -f, streams in real-time.
+
+Usage:  jdt launch logs <name> [-f|--follow] [--tail N]
+
+Flags:
+  -f, --follow   stream until process terminates (Ctrl+C to detach)
+  --tail <N>     last N lines only (snapshot), or start N lines back (follow)
+
+Examples:
+  jdt launch logs m8-server                full output snapshot
+  jdt launch logs m8-server --tail 30      last 30 lines
+  jdt launch logs m8-server -f             stream live
+  jdt launch logs m8-server -f | tail -20  wait + bounded output`;
+
+// Keep old name for backward compatibility
+export const launchConsoleHelp = launchLogsHelp;

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`;