@kaluchi/jdtbridge 1.3.0 → 1.5.0

package/README.md

@@ -45,8 +45,10 @@ jdt source <FQMN>                                      # (alias: src) source cod
 
 ```bash
 jdt build [--project <name>] [--clean]                 # (alias: b) build project
-jdt test <FQMN> [--timeout N]                           # run JUnit test class or method
-jdt test --project <name> [--package <pkg>]            # run tests in project/package
+jdt test run <FQN> [-f] [-q]                            # launch tests (non-blocking)
+jdt test run --project <name> [-f]                     # run tests in project
+jdt test status <session> [-f] [--all] [--ignored]     # show test progress/results
+jdt test sessions                                       # list test sessions
 ```
 
 All commands auto-refresh from disk. `build` is the only command that triggers explicit builds.
@@ -71,10 +73,26 @@ 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 editors                                             # (alias: ed) list all open editors (absolute paths)
 jdt open <FQMN>                                        # open in Eclipse editor
 ```
 

package/package.json

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

package/src/claude-setup.mjs

@@ -0,0 +1,83 @@
+// Configure Claude Code for JDT Bridge projects.
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { execSync } from "node:child_process";
+
+const JDT_HOOK_COMMAND = `node -e "d=JSON.parse(require('fs').readFileSync(0,'utf8'));d.tool_input?.command?.startsWith('jdt ')&&process.stdout.write(JSON.stringify({hookSpecificOutput:{hookEventName:'PreToolUse',permissionDecision:'allow'}}))"`;
+
+/**
+ * Find the project root (git root or cwd).
+ * @returns {string}
+ */
+export function findProjectRoot() {
+  try {
+    return execSync("git rev-parse --show-toplevel", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+  } catch {
+    return process.cwd();
+  }
+}
+
+/**
+ * Merge JDT Bridge settings into a Claude Code settings object.
+ * Idempotent — safe to call multiple times.
+ * @param {object} settings existing settings (mutated in place)
+ * @returns {object} the mutated settings
+ */
+export function mergeJdtSettings(settings) {
+  // Permissions
+  if (!settings.permissions) settings.permissions = {};
+  const allow = settings.permissions.allow || [];
+  if (!allow.includes("Bash(jdt *)")) allow.push("Bash(jdt *)");
+  settings.permissions.allow = allow;
+
+  // Hook
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = [];
+  const existing = settings.hooks.PreToolUse.find(
+    (h) =>
+      h.matcher === "Bash" &&
+      h.hooks?.some((hk) => hk.command === JDT_HOOK_COMMAND),
+  );
+  if (!existing) {
+    settings.hooks.PreToolUse.push({
+      matcher: "Bash",
+      hooks: [{ type: "command", command: JDT_HOOK_COMMAND }],
+    });
+  }
+
+  return settings;
+}
+
+/**
+ * Write Claude Code settings for JDT Bridge to a project.
+ * Creates .claude/settings.json if it doesn't exist,
+ * merges into existing if it does.
+ * @param {string} [root] project root (default: git root or cwd)
+ * @returns {{ file: string, settings: object }}
+ */
+export function installClaudeSettings(root) {
+  if (!root) root = findProjectRoot();
+
+  const dir = join(root, ".claude");
+  const file = join(dir, "settings.json");
+
+  let settings = {};
+  if (existsSync(file)) {
+    try {
+      settings = JSON.parse(readFileSync(file, "utf8"));
+    } catch {
+      // corrupt — overwrite
+    }
+  }
+
+  mergeJdtSettings(settings);
+
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(file, JSON.stringify(settings, null, 2) + "\n");
+
+  return { file, settings };
+}

package/src/cli.mjs

@@ -11,7 +11,9 @@ import { implementors, help as implementorsHelp } from "./commands/implementors.
 import { typeInfo, help as typeInfoHelp } from "./commands/type-info.mjs";
 import { source, help as sourceHelp } from "./commands/source.mjs";
 import { build, help as buildHelp } from "./commands/build.mjs";
-import { test, help as testHelp } from "./commands/test.mjs";
+import { testRun, help as testRunHelp } from "./commands/test-run.mjs";
+import { testStatus, help as testStatusHelp } from "./commands/test-status.mjs";
+import { testSessions, help as testSessionsHelp } from "./commands/test-sessions.mjs";
 import { errors, help as errorsHelp } from "./commands/errors.mjs";
 import {
   organizeImports,
@@ -24,11 +26,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 +56,75 @@ 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 testSubcommands = {
+  run: { fn: testRun, help: testRunHelp },
+  status: { fn: testStatus, help: testStatusHelp },
+  sessions: { fn: testSessions, help: testSessionsHelp },
+};
+
+const testHelp = `Run and monitor JUnit tests via Eclipse's built-in runner.
+
+Subcommands:
+  jdt test run <FQN> [-f] [-q]                launch tests (non-blocking)
+  jdt test status <session> [-f] [--all]      show test progress/results
+  jdt test sessions                           list test sessions
+
+Use "jdt help test <subcommand>" for details.`;
+
+async function testDispatch(args) {
+  const [sub, ...rest] = args;
+  if (!sub || sub === "--help") {
+    console.log(testHelp);
+    return;
+  }
+  const cmd = testSubcommands[sub];
+  if (!cmd) {
+    console.error(`Unknown test subcommand: ${sub}`);
+    console.log(testHelp);
+    process.exit(1);
+  }
+  await cmd.fn(rest);
+}
+
 const commands = {
   projects: { fn: projects, help: projectsHelp },
   "project-info": { fn: projectInfo, help: projectInfoHelp },
@@ -47,14 +136,15 @@ const commands = {
   "type-info": { fn: typeInfo, help: typeInfoHelp },
   source: { fn: source, help: sourceHelp },
   build: { fn: build, help: buildHelp },
-  test: { fn: test, help: testHelp },
+  test: { fn: testDispatch, help: testHelp },
   errors: { fn: errors, help: errorsHelp },
   "organize-imports": { fn: organizeImports, help: organizeImportsHelp },
   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 +157,7 @@ const aliases = {
   pi: "project-info",
   ti: "type-info",
   oi: "organize-imports",
-  ae: "active-editor",
+  ed: "editors",
   src: "source",
   b: "build",
   err: "errors",
@@ -104,12 +194,13 @@ Search & navigation:
   hierarchy${fmtAliases("hierarchy")} <FQN>                             full hierarchy (supers + interfaces + subtypes)
   implementors${fmtAliases("implementors")} <FQMN>                            implementations of interface method
   type-info${fmtAliases("type-info")} <FQN>                             class overview (fields, methods, line numbers)
-  source${fmtAliases("source")} <FQMN>                              type or method source code (project and libraries)
+  source${fmtAliases("source")} <FQMN>                              source + resolved references (navigation)
 
 Testing & building:
   build${fmtAliases("build")} [--project <name>] [--clean]      build project (incremental or clean)
-  test <FQMN>                                 run JUnit test class or method
-  test --project <name> [--package <pkg>]     run tests in project/package
+  test run <FQN> [-f] [-q]                    launch tests (non-blocking)
+  test status <session> [-f] [--all]          show test progress/results
+  test sessions                               list test sessions
 
 Diagnostics:
   errors${fmtAliases("errors")} [--file <path>] [--project <name>]   compilation errors
@@ -120,8 +211,17 @@ Refactoring:
   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
+  editors${fmtAliases("editors")}                                    list open editors (absolute paths)
   open <FQMN>                                 open in Eclipse editor
 
 Setup:
@@ -146,7 +246,11 @@ 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 === "test" && rest[1] && testSubcommands[rest[1]]) {
+      console.log(testSubcommands[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,93 @@ 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();
+  });
+}
+
+/**
+ * HTTP GET streaming with line-by-line callback. Designed for
+ * JSONL (newline-delimited JSON) endpoints. Calls onLine for
+ * each complete line received.
+ * Resolves when the server closes the connection.
+ * @param {string} path
+ * @param {(line: string) => void} onLine
+ * @returns {Promise<void>}
+ */
+export function getStreamLines(path, onLine) {
+  const inst = connect();
+  return new Promise((resolve, reject) => {
+    const req = request(
+      {
+        hostname: "127.0.0.1",
+        port: inst.port,
+        path,
+        method: "GET",
+        timeout: 0,
+        headers: authHeaders(),
+      },
+      (res) => {
+        if (res.statusCode !== 200) {
+          let data = "";
+          res.on("data", (chunk) => (data += chunk));
+          res.on("end", () => reject(new Error(data.trim())));
+          return;
+        }
+        let buffer = "";
+        res.on("data", (chunk) => {
+          buffer += chunk;
+          const lines = buffer.split("\n");
+          buffer = lines.pop();
+          for (const line of lines) {
+            if (line.trim()) onLine(line);
+          }
+        });
+        res.on("end", () => {
+          if (buffer.trim()) onLine(buffer);
+          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,17 +1,18 @@
 import { get } from "../client.mjs";
 import { extractPositional, parseFlags, parseFqmn } from "../args.mjs";
-import { stripProject } from "../paths.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);
   }
 }
 
@@ -38,15 +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[(param types)]]
 
 Examples:
-  jdt open app.m8.dao.StaffDaoImpl
-  jdt open app.m8.dao.StaffDaoImpl#getStaff
-  jdt open "app.m8.dao.StaffDaoImpl#save(Order)"`;
+  jdt open com.example.dao.UserDaoImpl
+  jdt open com.example.dao.UserDaoImpl#getStaff
+  jdt open "com.example.dao.UserDaoImpl#save(Order)"`;

package/src/commands/hierarchy.mjs

@@ -45,4 +45,4 @@ export const help = `Show full type hierarchy: superclasses, interfaces, and sub
 
 Usage:  jdt hierarchy <FQN>
 
-Example:  jdt hierarchy app.m8.web.client.AGMEntryPoint`;
+Example:  jdt hierarchy com.example.client.AppEntryPoint`;

package/src/commands/implementors.mjs

@@ -35,4 +35,4 @@ export const help = `Find implementations of an interface method across all impl
 Usage:  jdt implementors <FQN>#<method>[(param types)]
 
 Examples:
-  jdt implementors app.m8.web.shared.core.HasId#getId`;
+  jdt implementors com.example.core.HasId#getId`;