@kaluchi/jdtbridge 1.5.0 → 1.6.0

package/package.json

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

package/src/args.mjs

@@ -103,5 +103,17 @@ function splitParams(str) {
   }
   const last = str.substring(start).trim();
   if (last) params.push(last);
-  return params;
+  return params.map(eraseGenerics);
+}
+
+/** Strip generics: Map<String,Integer> → Map, List<String>[] → List[] */
+function eraseGenerics(type) {
+  let result = "";
+  let depth = 0;
+  for (const ch of type) {
+    if (ch === "<") depth++;
+    else if (ch === ">") depth--;
+    else if (depth === 0) result += ch;
+  }
+  return result;
 }

package/src/commands/hierarchy.mjs

@@ -1,7 +1,6 @@
 import { get } from "../client.mjs";
 import { extractPositional } from "../args.mjs";
-import { stripProject } from "../paths.mjs";
-import { bold } from "../color.mjs";
+import { formatHierarchy } from "../format/hierarchy.mjs";
 
 export async function hierarchy(args) {
   const pos = extractPositional(args);
@@ -18,26 +17,16 @@ export async function hierarchy(args) {
     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}`);
-    }
+
+  const lines = [];
+  lines.push(`#### ${result.fqn || fqn}`);
+  lines.push("");
+  lines.push(...formatHierarchy(result));
+
+  if (lines.length > 2) {
+    console.log(lines.join("\n"));
+  } else {
+    console.log("No hierarchy found.");
   }
 }
 

package/src/commands/source.mjs

@@ -1,5 +1,6 @@
 import { get } from "../client.mjs";
 import { extractPositional, parseFqmn } from "../args.mjs";
+import { formatHierEntry } from "../format/hierarchy.mjs";
 
 export async function source(args) {
   const jsonFlag = args.includes("--json");
@@ -91,8 +92,8 @@ function formatMemberRef(ref) {
   if (ref.inherited) annotations.push("inherited");
   if (annotations.length > 0) line += ` (${annotations.join(", ")})`;
 
-  // Line number (only for incoming)
-  if (ref.direction === "incoming" && ref.line) line += ` :${ref.line}`;
+  // Line number: server sends it but we don't render for incoming —
+  // callers are navigable by FQMN, line numbers just add noise
 
   // Javadoc inline after —
   if (ref.doc) line += ` — ${ref.doc}`;
@@ -126,19 +127,31 @@ function groupByDeclaringType(refs) {
   return groups;
 }
 
-function formatRefGroup({ typeFqn, group }, implIndex) {
+function formatRefGroup({ typeFqn, group }, implIndex, viewScope) {
   const lines = [];
-  if (group.typeRef) {
+  // Type header: only show for standalone type refs (no members).
+  // When members exist, the type is already visible in their FQMNs.
+  const standalone = group.members.length === 0;
+  if (standalone && group.typeRef) {
     lines.push(formatTypeHeader(group.typeRef));
-  } else if (group.members.length > 0) {
-    const tkBadge = TYPE_KIND_BADGE[group.members[0].typeKind] || "[C]";
-    lines.push(`${tkBadge} \`${typeFqn}\``);
+    // Show type implementations (domain-scoped)
+    const impls = implIndex[group.typeRef.fqmn];
+    if (impls && !(viewScope === "project" && group.typeRef.scope === "dependency")) {
+      for (const impl of impls) {
+        let implLine = `  ${badge(impl)} \`${impl.fqmn}\``;
+        if (impl.anonymous && impl.enclosingFqmn) {
+          implLine += ` — in \`${impl.enclosingFqmn}\``;
+        }
+        lines.push(implLine);
+      }
+    }
   }
   for (const ref of group.members) {
     lines.push(formatMemberRef(ref));
-    // Show implementations right after the interface method
+    // Show implementations — skip dependency interface impls
+    // when viewing project source (domain scoping)
     const impls = implIndex[ref.fqmn];
-    if (impls) {
+    if (impls && !(viewScope === "project" && ref.scope === "dependency")) {
       for (const impl of impls) {
         lines.push(`  → ${badge(impl)} \`${impl.fqmn}\``);
       }
@@ -159,21 +172,20 @@ function buildImplIndex(refs) {
   return index;
 }
 
+
 // ---- Hierarchy (type-level) ----
 
-function formatHierarchy(lines, result) {
+function formatHierarchySection(lines, result) {
   const supers = result.supertypes || [];
   const subs = result.subtypes || [];
   if (supers.length > 0 || subs.length > 0) {
     lines.push("");
     lines.push("#### Hierarchy:");
     for (const s of supers) {
-      const b = TYPE_KIND_BADGE[s.kind] || "[C]";
-      lines.push(`↑ ${b} \`${s.fqn}\``);
+      lines.push(...formatHierEntry("↑", s));
     }
     for (const s of subs) {
-      const b = TYPE_KIND_BADGE[s.kind] || "[C]";
-      lines.push(`↓ ${b} \`${s.fqn}\``);
+      lines.push(...formatHierEntry("", s));
     }
   }
   if (result.enclosingType) {
@@ -182,7 +194,7 @@ function formatHierarchy(lines, result) {
     const et = result.enclosingType;
     const fqn = typeof et === "string" ? et : et.fqn;
     const kind = typeof et === "string" ? "class" : (et.kind || "class");
-    lines.push(`${TYPE_KIND_BADGE[kind] || "[C]"} \`${fqn}\``);
+    lines.push(...formatHierEntry("", { fqn, kind, ...et }));
   }
 }
 
@@ -212,7 +224,7 @@ function formatMarkdown(result) {
 
   // Type-level: hierarchy instead of refs
   if (result.supertypes || result.subtypes) {
-    formatHierarchy(lines, result);
+    formatHierarchySection(lines, result);
     return lines.join("\n");
   }
 
@@ -220,10 +232,32 @@ function formatMarkdown(result) {
     return lines.join("\n");
   }
 
-  // Split by direction
-  const outgoing = result.refs.filter((r) => r.direction !== "incoming");
+  // Self-reference: the viewed member's declaring type
+  const selfFqn = result.fqmn.includes("#")
+    ? result.fqmn.split("#")[0] : null;
+
+  // Split by direction, filter self-reference type refs
+  const outgoing = result.refs.filter((r) =>
+    r.direction !== "incoming"
+    && !(r.kind === "type" && r.fqmn === selfFqn));
   const incoming = result.refs.filter((r) => r.direction === "incoming");
 
+  const viewScope = result.viewScope;
+
+  // Implementations section (interface/abstract methods)
+  const impls = result.implementations || [];
+  if (impls.length > 0) {
+    lines.push("");
+    lines.push("#### Implementations:");
+    for (const impl of impls) {
+      let line = `[M] \`${impl.fqmn}\``;
+      if (impl.anonymous && impl.enclosingFqmn) {
+        line += ` — in \`${impl.enclosingFqmn}\``;
+      }
+      lines.push(line);
+    }
+  }
+
   if (outgoing.length > 0) {
     const implIndex = buildImplIndex(outgoing);
     const mainRefs = outgoing.filter((r) => !r.implementationOf);
@@ -231,7 +265,7 @@ function formatMarkdown(result) {
     lines.push("#### Outgoing Calls:");
     const groups = groupByDeclaringType(mainRefs);
     for (const g of groups) {
-      lines.push(formatRefGroup(g, implIndex));
+      lines.push(formatRefGroup(g, implIndex, viewScope));
     }
   }
 
@@ -242,7 +276,7 @@ function formatMarkdown(result) {
     lines.push("#### Incoming Calls:");
     const groups = groupByDeclaringType(mainRefs);
     for (const g of groups) {
-      lines.push(formatRefGroup(g, implIndex));
+      lines.push(formatRefGroup(g, implIndex, viewScope));
     }
   }
 

package/src/format/hierarchy.mjs

@@ -0,0 +1,47 @@
+const TYPE_KIND_BADGE = {
+  class: "[C]",
+  interface: "[I]",
+  enum: "[E]",
+  annotation: "[A]",
+};
+
+export function formatHierEntry(arrow, s) {
+  const depth = s.depth || 0;
+  const indent = "  ".repeat(depth);
+  const b = TYPE_KIND_BADGE[s.kind] || "[C]";
+  const prefix = arrow ? `${arrow} ` : "";
+  let line = `${indent}- ${prefix}${b} \`${s.fqn}\``;
+  if (s.anonymous && s.enclosingFqmn) {
+    line += ` — in \`${s.enclosingFqmn}\``;
+  }
+  const lines = [line];
+  if (s.file) {
+    let loc = s.file;
+    if (s.line) {
+      loc += `:${s.line}`;
+      if (s.endLine && s.endLine !== s.line) loc += `-${s.endLine}`;
+    }
+    lines.push(`${indent}  \`${loc}\``);
+  }
+  return lines;
+}
+
+export function formatHierarchy(result) {
+  const lines = [];
+  const supers = result.supertypes || [];
+  const subs = result.subtypes || [];
+  if (supers.length > 0) {
+    lines.push("#### Supertypes:");
+    for (const s of supers) {
+      lines.push(...formatHierEntry("↑", s));
+    }
+  }
+  if (subs.length > 0) {
+    if (lines.length > 0) lines.push("");
+    lines.push("#### Subtypes:");
+    for (const s of subs) {
+      lines.push(...formatHierEntry("", s));
+    }
+  }
+  return lines;
+}