@kaluchi/jdtbridge 1.1.0

package/src/commands/errors.mjs

@@ -0,0 +1,52 @@
+import { get } from "../client.mjs";
+import { parseFlags } from "../args.mjs";
+import { stripProject, toWsPath } from "../paths.mjs";
+import { red, yellow } from "../color.mjs";
+
+export async function errors(args) {
+  const flags = parseFlags(args);
+  const params = [];
+  if (flags.file) params.push(`file=${encodeURIComponent(toWsPath(flags.file))}`);
+  if (flags.project) params.push(`project=${encodeURIComponent(flags.project)}`);
+  if (flags.warnings) params.push("warnings");
+  if (flags.all) params.push("all");
+
+  let url = "/errors";
+  if (params.length > 0) url += "?" + params.join("&");
+  const results = await get(url, 180_000);
+  if (results.error) {
+    console.error(results.error);
+    process.exit(1);
+  }
+  if (results.length === 0) {
+    console.log("(no errors)");
+    return;
+  }
+
+  for (const r of results) {
+    const sev = r.severity === "ERROR" ? red("ERROR") : yellow("WARN ");
+    const src = r.source ? `[${r.source}] ` : "";
+    console.log(`${sev} ${src}${stripProject(r.file)}:${r.line}  ${r.message}`);
+  }
+}
+
+export const help = `Check compilation errors and diagnostics.
+
+Usage:  jdt errors [--file <path>] [--project <name>]
+                   [--warnings] [--all]
+
+Scope (pick one or omit for entire workspace):
+  --file <path>       single file (workspace-relative)
+  --project <name>    entire project
+
+Options:
+  --warnings          include warnings (default: errors only)
+  --all               all marker types (jdt + checkstyle + maven + ...)
+
+Refreshes from disk and waits for auto-build before reading markers.
+Use 'jdt build' to trigger explicit builds.
+
+Examples:
+  jdt errors --project m8-server
+  jdt errors --file m8-server/src/main/java/.../Foo.java
+  jdt errors --project m8-server --all --warnings`;

package/src/commands/find.mjs

@@ -0,0 +1,41 @@
+import { get } from "../client.mjs";
+import { extractPositional } from "../args.mjs";
+import { stripProject } from "../paths.mjs";
+
+export async function find(args) {
+  const pos = extractPositional(args);
+  const name = pos[0];
+  if (!name) {
+    console.error("Usage: find <Name|Pattern> [--source-only]");
+    process.exit(1);
+  }
+  let url = `/find?name=${encodeURIComponent(name)}`;
+  if (args.includes("--source-only")) url += "&source";
+  const results = await get(url, 30_000);
+  if (results.error) {
+    console.error(results.error);
+    process.exit(1);
+  }
+  if (results.length === 0) {
+    console.log("(no results)");
+    return;
+  }
+  for (const r of results) {
+    console.log(`${r.fqn}  ${stripProject(r.file)}`);
+  }
+}
+
+export const help = `Find type declarations by name or wildcard pattern.
+
+Usage:  jdt find <Name|*Pattern*> [--source-only]
+
+Arguments:
+  Name        exact type name (e.g. DataSourceUtils)
+  *Pattern*   wildcard pattern (e.g. *Controller*, Find*)
+
+Flags:
+  --source-only   exclude binary/library types, show only workspace sources
+
+Examples:
+  jdt find DataSourceUtils
+  jdt find *Controller* --source-only`;

package/src/commands/hierarchy.mjs

@@ -0,0 +1,48 @@
+import { get } from "../client.mjs";
+import { extractPositional } from "../args.mjs";
+import { stripProject } from "../paths.mjs";
+import { bold } from "../color.mjs";
+
+export async function hierarchy(args) {
+  const pos = extractPositional(args);
+  const fqn = pos[0];
+  if (!fqn) {
+    console.error("Usage: hierarchy <FQN>");
+    process.exit(1);
+  }
+  const result = await get(
+    `/hierarchy?class=${encodeURIComponent(fqn)}`,
+    30_000,
+  );
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  if (result.supers.length > 0) {
+    console.log(bold("Superclasses:"));
+    for (const s of result.supers) {
+      const loc = s.binary ? "(binary)" : stripProject(s.file);
+      console.log(`  ${s.fqn}  ${loc}`);
+    }
+  }
+  if (result.interfaces.length > 0) {
+    console.log(bold("Interfaces:"));
+    for (const s of result.interfaces) {
+      const loc = s.binary ? "(binary)" : stripProject(s.file);
+      console.log(`  ${s.fqn}  ${loc}`);
+    }
+  }
+  if (result.subtypes.length > 0) {
+    console.log(bold("Subtypes:"));
+    for (const s of result.subtypes) {
+      const loc = s.binary ? "(binary)" : stripProject(s.file);
+      console.log(`  ${s.fqn}  ${loc}`);
+    }
+  }
+}
+
+export const help = `Show full type hierarchy: superclasses, interfaces, and subtypes.
+
+Usage:  jdt hierarchy <FQN>
+
+Example:  jdt hierarchy app.m8.web.client.AGMEntryPoint`;

package/src/commands/implementors.mjs

@@ -0,0 +1,34 @@
+import { get } from "../client.mjs";
+import { extractPositional, parseFlags } 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;
+  if (!fqn || !method) {
+    console.error("Usage: implementors <FQN> <method> [--arity n]");
+    process.exit(1);
+  }
+  let url = `/implementors?class=${encodeURIComponent(fqn)}&method=${encodeURIComponent(method)}`;
+  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);
+    process.exit(1);
+  }
+  if (results.length === 0) {
+    console.log("(no implementors)");
+    return;
+  }
+  for (const r of results) {
+    console.log(`${r.fqn}  ${stripProject(r.file)}:${r.line}`);
+  }
+}
+
+export const help = `Find implementations of an interface method across all implementing classes.
+
+Usage:  jdt implementors <FQN> <method> [--arity <n>]
+
+Example:  jdt implementors app.m8.web.shared.core.HasId getId`;

package/src/commands/project-info.mjs

@@ -0,0 +1,45 @@
+import { get } from "../client.mjs";
+import { extractPositional, parseFlags } from "../args.mjs";
+import { formatProjectInfo } from "../format/project-info.mjs";
+
+export async function projectInfo(args) {
+  const pos = extractPositional(args);
+  const flags = parseFlags(args);
+  const name = pos[0];
+  if (!name) {
+    console.error(
+      "Usage: project-info <name> [--lines N] [--members-threshold N]",
+    );
+    process.exit(1);
+  }
+  let url = `/project-info?project=${encodeURIComponent(name)}`;
+  if (flags["members-threshold"])
+    url += `&members-threshold=${flags["members-threshold"]}`;
+  const result = await get(url, 30_000);
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  const maxLines = parseInt(flags.lines) || 50;
+  console.log(formatProjectInfo(result, maxLines));
+}
+
+export const help = `Show project overview with adaptive detail level.
+
+Usage:  jdt project-info <name> [--lines N] [--members-threshold N]
+
+Arguments:
+  name    Eclipse project name (e.g. m8-server, io.github.kaluchi.jdtbridge)
+
+Flags:
+  --lines <N>               max output lines (default: 50)
+  --members-threshold <N>   include method signatures when totalTypes <= N (default: 200)
+
+Detail adapts to --lines budget:
+  - Small budget: location + source roots + dependencies + package list
+  - Medium budget: + type names per package
+  - Large budget: + method signatures per type (if server included them)
+
+Examples:
+  jdt project-info m8-server
+  jdt project-info m8-server --lines 100`;

package/src/commands/projects.mjs

@@ -0,0 +1,16 @@
+import { get } from "../client.mjs";
+
+export async function projects() {
+  const results = await get("/projects");
+  if (results.error) {
+    console.error(results.error);
+    process.exit(1);
+  }
+  for (const p of results) console.log(p);
+}
+
+export const help = `List all Java projects in the Eclipse workspace.
+
+Usage:  jdt projects
+
+Output: one project name per line.`;

package/src/commands/refactoring.mjs

@@ -0,0 +1,116 @@
+import { get } from "../client.mjs";
+import { extractPositional, parseFlags } from "../args.mjs";
+import { toWsPath } from "../paths.mjs";
+import { green, yellow } from "../color.mjs";
+
+export async function organizeImports(args) {
+  const pos = extractPositional(args);
+  const filePath = pos[0];
+  if (!filePath) {
+    console.error("Usage: organize-imports <workspace-relative-path>");
+    process.exit(1);
+  }
+  const result = await get(
+    `/organize-imports?file=${encodeURIComponent(toWsPath(filePath))}`,
+    30_000,
+  );
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  console.log(`Imports: +${result.added} -${result.removed}`);
+}
+
+export async function format(args) {
+  const pos = extractPositional(args);
+  const filePath = pos[0];
+  if (!filePath) {
+    console.error("Usage: format <workspace-relative-path>");
+    process.exit(1);
+  }
+  const result = await get(
+    `/format?file=${encodeURIComponent(toWsPath(filePath))}`,
+    30_000,
+  );
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  if (result.modified) {
+    console.log(green("Formatted"));
+  } else {
+    console.log(`No changes${result.reason ? ": " + result.reason : ""}`);
+  }
+}
+
+export async function rename(args) {
+  const pos = extractPositional(args);
+  const flags = parseFlags(args);
+  const fqn = pos[0];
+  const newName = pos[1];
+  if (!fqn || !newName) {
+    console.error(
+      "Usage: rename <FQN> <newName> [--field name] [--method name] [--arity n]",
+    );
+    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}`;
+  const result = await get(url, 30_000);
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  console.log(green("Renamed"));
+  if (result.warnings) {
+    for (const w of result.warnings) console.log(yellow(`  warning: ${w}`));
+  }
+}
+
+export async function move(args) {
+  const pos = extractPositional(args);
+  const [fqn, target] = pos;
+  if (!fqn || !target) {
+    console.error("Usage: move <FQN> <target.package>");
+    process.exit(1);
+  }
+  const url = `/move?class=${encodeURIComponent(fqn)}&target=${encodeURIComponent(target)}`;
+  const result = await get(url, 30_000);
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  console.log(green("Moved"));
+  if (result.warnings) {
+    for (const w of result.warnings) console.log(yellow(`  warning: ${w}`));
+  }
+}
+
+export const organizeImportsHelp = `Organize imports in a Java file.
+
+Usage:  jdt organize-imports <file>
+
+Example:  jdt organize-imports m8-server/src/main/java/.../Foo.java`;
+
+export const formatHelp = `Format a Java file using Eclipse project settings.
+
+Usage:  jdt format <file>
+
+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>]
+
+Examples:
+  jdt rename app.m8.dto.Foo Bar
+  jdt rename app.m8.dto.Foo getBar --method getFoo`;
+
+export const moveHelp = `Move a type to another package (updates all references).
+
+Usage:  jdt move <FQN> <target.package>
+
+Example:  jdt move app.m8.dto.Foo app.m8.dto.shared`;

package/src/commands/references.mjs

@@ -0,0 +1,51 @@
+import { get } from "../client.mjs";
+import { extractPositional, parseFlags } 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];
+  if (!fqn) {
+    console.error("Usage: references <FQN> [method] [--field name] [--arity n]");
+    process.exit(1);
+  }
+  let url = `/references?class=${encodeURIComponent(fqn)}`;
+  if (flags.field) {
+    url += `&field=${encodeURIComponent(flags.field)}`;
+  } else {
+    const method = pos[1];
+    if (method) url += `&method=${encodeURIComponent(method)}`;
+  }
+  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);
+    process.exit(1);
+  }
+  if (results.length === 0) {
+    console.log("(no references)");
+    return;
+  }
+  formatReferences(results);
+}
+
+export const help = `Find all references to a type, method, or field across the workspace.
+
+Usage:  jdt references <FQN> [method]
+        jdt references <FQN> --field <name>
+        jdt references <FQN> [method] --arity <n>
+
+Arguments:
+  FQN       fully qualified class name
+  method    method name (optional)
+
+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 --field staffCache`;