feat(detector/class-hierarchy): consume ctx.resolved() for RESOLVED EXTENDS/IMPLEMENTS edges

Phase 6 task 24-style migration applied to ClassHierarchyDetector.
Class hierarchy is high-leverage for resolution: simple-name superclass
references like "extends Service" are routine across unrelated codebases,
and EXTENDS / IMPLEMENTS edges are downstream-load-bearing for
blast-radius / dead-code / cycle / topology analysis. Pinning the
target FQN turns "Service-named-something" into a stable cross-file
reference.

When ctx.resolved() carries a JavaResolved, the detector now:

  1. Uses the resolver-parsed CompilationUnit (symbol solver attached).
  2. For each parent type in extendedTypes / implementedTypes, calls
     a single new helper addHierarchyEdge() that:
       - tries to resolve the type via the symbol solver
       - on success, attaches target_fqn to edge properties + stamps
         Confidence.RESOLVED + source = "java.class_hierarchy"
       - on failure (and always when ctx.resolved() is empty), emits
         the existing simple-name placeholder edge with raw default
         confidence (orchestrator stamps SYNTACTIC at the boundary).
  3. The 4 prior in-line edge-emission blocks (class-extends,
     interface-extends, class-implements, enum-implements) collapse to
     two-line iterations through addHierarchyEdge — net is fewer LOC
     plus the new resolution capability.

Existing 30 ClassHierarchyDetectorExtended tests pass unchanged — node
emission, regex fallback, the property shapes, and the simple-name
edge IDs / target placeholders are all preserved.

5 new tests in ClassHierarchyDetectorResolvedTest:
  - resolvedModeStampsResolvedTierOnExtendsEdge — two BaseService in
    different packages; imported one wins on edge.target_fqn.
  - resolvedModeStampsResolvedTierOnImplementsEdge — same shape for
    interface implements.
  - fallbackModeMatchesPreSpecBaseline — EmptyResolved → no FQN, no
    RESOLVED stamp.
  - fallbackModeWhenContextHasNoResolvedAtAll — Optional.empty() also
    safe.
  - mixedModeFallsBackForUnreachableType — class extends a known type,
    implements an unknown one: EXTENDS is RESOLVED, IMPLEMENTS falls
    back gracefully.

This brings the migrated-detector count to 4 (JpaEntityDetector,
RepositoryDetector, SpringRestDetector, ClassHierarchyDetector) — at
the lower bound of the plan's "4-6 Java detectors migrated as proof of
value".

Plan: docs/plans/2026-04-27-sub-project-1-resolver-spi-and-java-pilot.md
(spirit of tasks 24-29 — using the actual detectors that exist in this
repo, not the plan's hypothetical names).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: aksOps

src/main/java/io/github/randomcodespace/iq/detector/jvm/java/ClassHierarchyDetector.java

@@ -5,10 +5,14 @@
 import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
 import com.github.javaparser.ast.body.EnumDeclaration;
 import com.github.javaparser.ast.type.ClassOrInterfaceType;
+import com.github.javaparser.resolution.types.ResolvedType;
 import io.github.randomcodespace.iq.detector.DetectorContext;
 import io.github.randomcodespace.iq.detector.DetectorResult;
+import io.github.randomcodespace.iq.intelligence.resolver.Resolved;
+import io.github.randomcodespace.iq.intelligence.resolver.java.JavaResolved;
 import io.github.randomcodespace.iq.model.CodeEdge;
 import io.github.randomcodespace.iq.model.CodeNode;
+import io.github.randomcodespace.iq.model.Confidence;
 import io.github.randomcodespace.iq.model.EdgeKind;
 import io.github.randomcodespace.iq.model.NodeKind;
 import org.springframework.stereotype.Component;
@@ -71,16 +75,28 @@ public DetectorResult detect(DetectorContext ctx) {
         String text = ctx.content();
         if (text == null || text.isEmpty()) return DetectorResult.empty();
 
-        Optional<CompilationUnit> cu = parse(ctx);
+        // Prefer the resolver-parsed CU when ctx.resolved() carries a
+        // JavaResolved — class hierarchy benefits a lot from FQN resolution
+        // because superclass / interface refs are routinely simple-named in
+        // source ("extends Service" not "extends com.example.Service") and
+        // EXTENDS/IMPLEMENTS edges are downstream-load-bearing.
+        Optional<JavaResolved> resolved = ctx.resolved()
+                .filter(Resolved::isAvailable)
+                .filter(JavaResolved.class::isInstance)
+                .map(JavaResolved.class::cast);
+
+        Optional<CompilationUnit> cu = resolved.map(JavaResolved::cu).or(() -> parse(ctx));
         if (cu.isPresent()) {
-            return detectWithAst(cu.get(), ctx);
+            return detectWithAst(cu.get(), ctx, resolved);
         }
         return detectWithRegex(ctx);
     }
 
     // ==================== AST-based detection ====================
 
-    private DetectorResult detectWithAst(CompilationUnit cu, DetectorContext ctx) {
+    private DetectorResult detectWithAst(CompilationUnit cu, DetectorContext ctx,
+                                          Optional<JavaResolved> resolved) {
+        boolean canResolve = resolved.isPresent();
         List<CodeNode> nodes = new ArrayList<>();
         List<CodeEdge> edges = new ArrayList<>();
 
@@ -144,36 +160,17 @@ private DetectorResult detectWithAst(CompilationUnit cu, DetectorContext ctx) {
             node.setProperties(props);
             nodes.add(node);
 
-            // EXTENDS edges
-            if (!isInterface) {
-                for (String superclass : extendedTypes) {
-                    CodeEdge edge = new CodeEdge();
-                    edge.setId(nodeId + "->extends->*:" + superclass);
-                    edge.setKind(EdgeKind.EXTENDS);
-                    edge.setSourceId(nodeId);
-                    edge.setTarget(new CodeNode("*:" + superclass, NodeKind.CLASS, superclass));
-                    edges.add(edge);
-                }
-            } else {
-                // Interfaces extend other interfaces
-                for (String ext : extendedTypes) {
-                    CodeEdge edge = new CodeEdge();
-                    edge.setId(nodeId + "->extends->*:" + ext);
-                    edge.setKind(EdgeKind.EXTENDS);
-                    edge.setSourceId(nodeId);
-                    edge.setTarget(new CodeNode("*:" + ext, NodeKind.INTERFACE, ext));
-                    edges.add(edge);
-                }
+            // EXTENDS edges — iterate the typed AST nodes (not the simple-name
+            // strings) so we can attempt FQN resolution per-type when ctx
+            // carries a JavaResolved.
+            NodeKind extendsTargetKind = isInterface ? NodeKind.INTERFACE : NodeKind.CLASS;
+            for (ClassOrInterfaceType ext : decl.getExtendedTypes()) {
+                addHierarchyEdge(nodeId, ext, EdgeKind.EXTENDS, extendsTargetKind, canResolve, edges);
             }
 
             // IMPLEMENTS edges
-            for (String iface : implementedTypes) {
-                CodeEdge edge = new CodeEdge();
-                edge.setId(nodeId + "->implements->*:" + iface);
-                edge.setKind(EdgeKind.IMPLEMENTS);
-                edge.setSourceId(nodeId);
-                edge.setTarget(new CodeNode("*:" + iface, NodeKind.INTERFACE, iface));
-                edges.add(edge);
+            for (ClassOrInterfaceType impl : decl.getImplementedTypes()) {
+                addHierarchyEdge(nodeId, impl, EdgeKind.IMPLEMENTS, NodeKind.INTERFACE, canResolve, edges);
             }
         });
 
@@ -212,13 +209,8 @@ private DetectorResult detectWithAst(CompilationUnit cu, DetectorContext ctx) {
             node.setProperties(props);
             nodes.add(node);
 
-            for (String iface : interfaces) {
-                CodeEdge edge = new CodeEdge();
-                edge.setId(nodeId + "->implements->*:" + iface);
-                edge.setKind(EdgeKind.IMPLEMENTS);
-                edge.setSourceId(nodeId);
-                edge.setTarget(new CodeNode("*:" + iface, NodeKind.INTERFACE, iface));
-                edges.add(edge);
+            for (ClassOrInterfaceType impl : decl.getImplementedTypes()) {
+                addHierarchyEdge(nodeId, impl, EdgeKind.IMPLEMENTS, NodeKind.INTERFACE, canResolve, edges);
             }
         });
 
@@ -435,4 +427,46 @@ private List<String> parseTypeList(String typeList) {
         }
         return result;
     }
+
+    /**
+     * Emit an EXTENDS or IMPLEMENTS edge for a single type reference. When
+     * {@code canResolve} is true the helper attempts FQN resolution via the
+     * symbol solver and, on success, attaches {@code target_fqn} +
+     * {@link Confidence#RESOLVED} + source. The simple-name placeholder
+     * target is unchanged so EntityLinker / ClassHierarchyLinker post-passes
+     * are unaffected on the surface — they can opt to use {@code target_fqn}
+     * when present.
+     */
+    private void addHierarchyEdge(String sourceId, ClassOrInterfaceType target,
+                                    EdgeKind edgeKind, NodeKind targetKind,
+                                    boolean canResolve, List<CodeEdge> edges) {
+        String simpleName = target.getNameAsString();
+        Optional<String> fqn = canResolve ? tryResolveFqn(target) : Optional.empty();
+
+        CodeEdge edge = new CodeEdge();
+        edge.setId(sourceId + "->" + edgeKind.getValue() + "->*:" + simpleName);
+        edge.setKind(edgeKind);
+        edge.setSourceId(sourceId);
+        edge.setTarget(new CodeNode("*:" + simpleName, targetKind, simpleName));
+        if (fqn.isPresent()) {
+            Map<String, Object> props = new LinkedHashMap<>();
+            props.put("target_fqn", fqn.get());
+            edge.setProperties(props);
+            edge.setConfidence(Confidence.RESOLVED);
+            edge.setSource(getName());
+        }
+        edges.add(edge);
+    }
+
+    private static Optional<String> tryResolveFqn(ClassOrInterfaceType type) {
+        try {
+            ResolvedType rt = type.resolve();
+            if (rt.isReferenceType()) {
+                return Optional.of(rt.asReferenceType().getQualifiedName());
+            }
+            return Optional.of(rt.describe());
+        } catch (RuntimeException e) {
+            return Optional.empty();
+        }
+    }
 }

src/test/java/io/github/randomcodespace/iq/detector/jvm/java/ClassHierarchyDetectorResolvedTest.java

@@ -0,0 +1,223 @@
+package io.github.randomcodespace.iq.detector.jvm.java;
+
+import io.github.randomcodespace.iq.analyzer.DiscoveredFile;
+import io.github.randomcodespace.iq.detector.DetectorContext;
+import io.github.randomcodespace.iq.detector.DetectorResult;
+import io.github.randomcodespace.iq.intelligence.resolver.EmptyResolved;
+import io.github.randomcodespace.iq.intelligence.resolver.ResolutionException;
+import io.github.randomcodespace.iq.intelligence.resolver.Resolved;
+import io.github.randomcodespace.iq.intelligence.resolver.java.JavaResolved;
+import io.github.randomcodespace.iq.intelligence.resolver.java.JavaSourceRootDiscovery;
+import io.github.randomcodespace.iq.intelligence.resolver.java.JavaSymbolResolver;
+import io.github.randomcodespace.iq.model.CodeEdge;
+import io.github.randomcodespace.iq.model.Confidence;
+import io.github.randomcodespace.iq.model.EdgeKind;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Phase 6 — ClassHierarchyDetector migration to consume {@code ctx.resolved()}
+ * and stamp EXTENDS / IMPLEMENTS edges as RESOLVED with stable FQN targets
+ * when the symbol solver can pin them.
+ *
+ * <p>Class hierarchy resolution is high-leverage: the simple name "Service"
+ * appears in dozens of unrelated codebases at once and EXTENDS / IMPLEMENTS
+ * edges are downstream-load-bearing for blast-radius / dead-code / cycle
+ * analysis. Pinning the FQN turns the edge from "Service-named-something"
+ * into "this exact superclass".
+ *
+ * <p>Three contract tests:
+ * <ol>
+ *   <li><b>resolvedModeStampsResolvedTierOnExtendsEdge</b> — two
+ *       {@code BaseService} classes in different packages; resolution picks
+ *       the imported one for the EXTENDS edge.</li>
+ *   <li><b>fallbackModeMatchesPreSpecBaseline</b> — EmptyResolved → simple-
+ *       name target, no target_fqn, no RESOLVED stamp.</li>
+ *   <li><b>mixedModeUsesResolverWhereAvailable</b> — a class that extends a
+ *       resolvable type and implements an unresolvable one: EXTENDS is
+ *       RESOLVED, IMPLEMENTS falls back.</li>
+ * </ol>
+ */
+class ClassHierarchyDetectorResolvedTest {
+
+    @TempDir Path repoRoot;
+
+    private final ClassHierarchyDetector detector = new ClassHierarchyDetector();
+    private JavaSymbolResolver resolver;
+
+    @BeforeEach
+    void setUp() throws IOException {
+        Files.createDirectories(repoRoot.resolve("src/main/java/com/example/a"));
+        Files.createDirectories(repoRoot.resolve("src/main/java/com/example/b"));
+        Files.writeString(repoRoot.resolve("pom.xml"), "<project/>");
+
+        Files.writeString(repoRoot.resolve("src/main/java/com/example/a/BaseService.java"),
+                """
+                package com.example.a;
+                public class BaseService {}
+                """);
+        Files.writeString(repoRoot.resolve("src/main/java/com/example/b/BaseService.java"),
+                """
+                package com.example.b;
+                public class BaseService {}
+                """);
+        Files.writeString(repoRoot.resolve("src/main/java/com/example/a/Auditable.java"),
+                """
+                package com.example.a;
+                public interface Auditable {}
+                """);
+
+        resolver = new JavaSymbolResolver(new JavaSourceRootDiscovery());
+    }
+
+    // ── (1) Resolved mode ────────────────────────────────────────────────────
+
+    @Test
+    void resolvedModeStampsResolvedTierOnExtendsEdge() throws Exception {
+        // Pet extends BaseService — two BaseService classes in different
+        // packages, only the imported one wins.
+        String petPath = "src/main/java/com/example/PetService.java";
+        Path absPet = repoRoot.resolve(petPath);
+        Files.createDirectories(absPet.getParent());
+        String content = """
+                package com.example;
+                import com.example.a.BaseService;
+                public class PetService extends BaseService {}
+                """;
+        Files.writeString(absPet, content);
+
+        Resolved resolved = bootstrapAndResolve(petPath, content);
+        assertInstanceOf(JavaResolved.class, resolved);
+
+        DetectorContext ctx = ctxFor(petPath, content).withResolved(resolved);
+        DetectorResult result = detector.detect(ctx);
+
+        CodeEdge extendsEdge = onlyEdge(result, EdgeKind.EXTENDS);
+        assertEquals("com.example.a.BaseService", extendsEdge.getProperties().get("target_fqn"));
+        assertEquals(Confidence.RESOLVED, extendsEdge.getConfidence());
+        assertEquals(detector.getName(), extendsEdge.getSource());
+    }
+
+    @Test
+    void resolvedModeStampsResolvedTierOnImplementsEdge() throws Exception {
+        String petPath = "src/main/java/com/example/PetService.java";
+        Path absPet = repoRoot.resolve(petPath);
+        Files.createDirectories(absPet.getParent());
+        String content = """
+                package com.example;
+                import com.example.a.Auditable;
+                public class PetService implements Auditable {}
+                """;
+        Files.writeString(absPet, content);
+
+        Resolved resolved = bootstrapAndResolve(petPath, content);
+        DetectorContext ctx = ctxFor(petPath, content).withResolved(resolved);
+        DetectorResult result = detector.detect(ctx);
+
+        CodeEdge implementsEdge = onlyEdge(result, EdgeKind.IMPLEMENTS);
+        assertEquals("com.example.a.Auditable", implementsEdge.getProperties().get("target_fqn"));
+        assertEquals(Confidence.RESOLVED, implementsEdge.getConfidence());
+    }
+
+    // ── (2) Fallback mode ────────────────────────────────────────────────────
+
+    @Test
+    void fallbackModeMatchesPreSpecBaseline() throws Exception {
+        String petPath = "src/main/java/com/example/PetService.java";
+        Path absPet = repoRoot.resolve(petPath);
+        Files.createDirectories(absPet.getParent());
+        String content = """
+                package com.example;
+                import com.example.a.BaseService;
+                public class PetService extends BaseService {}
+                """;
+        Files.writeString(absPet, content);
+
+        DetectorContext ctx = ctxFor(petPath, content).withResolved(EmptyResolved.INSTANCE);
+        DetectorResult result = detector.detect(ctx);
+
+        CodeEdge extendsEdge = onlyEdge(result, EdgeKind.EXTENDS);
+        assertNull(extendsEdge.getProperties().get("target_fqn"),
+                "EmptyResolved → no FQN attempt, no target_fqn");
+        assertNotEquals(Confidence.RESOLVED, extendsEdge.getConfidence());
+        assertNull(extendsEdge.getSource());
+    }
+
+    @Test
+    void fallbackModeWhenContextHasNoResolvedAtAll() throws Exception {
+        String petPath = "src/main/java/com/example/PetService.java";
+        Path absPet = repoRoot.resolve(petPath);
+        Files.createDirectories(absPet.getParent());
+        String content = """
+                package com.example;
+                public class PetService extends BaseService {}
+                """;
+        Files.writeString(absPet, content);
+
+        DetectorContext ctx = ctxFor(petPath, content);
+        DetectorResult result = detector.detect(ctx);
+
+        CodeEdge extendsEdge = onlyEdge(result, EdgeKind.EXTENDS);
+        assertNull(extendsEdge.getProperties().get("target_fqn"));
+        assertNotEquals(Confidence.RESOLVED, extendsEdge.getConfidence());
+    }
+
+    // ── (3) Mixed mode ───────────────────────────────────────────────────────
+
+    @Test
+    void mixedModeFallsBackForUnreachableType() throws Exception {
+        // Class extends a known type and implements an unknown one.
+        // Expect: EXTENDS edge gets RESOLVED, IMPLEMENTS edge falls back.
+        String petPath = "src/main/java/com/example/PetService.java";
+        Path absPet = repoRoot.resolve(petPath);
+        Files.createDirectories(absPet.getParent());
+        String content = """
+                package com.example;
+                import com.example.a.BaseService;
+                public class PetService extends BaseService implements MysteryAware {}
+                """;
+        Files.writeString(absPet, content);
+
+        Resolved resolved = bootstrapAndResolve(petPath, content);
+        DetectorContext ctx = ctxFor(petPath, content).withResolved(resolved);
+        DetectorResult result = detector.detect(ctx);
+
+        CodeEdge extendsEdge = onlyEdge(result, EdgeKind.EXTENDS);
+        assertEquals("com.example.a.BaseService", extendsEdge.getProperties().get("target_fqn"));
+        assertEquals(Confidence.RESOLVED, extendsEdge.getConfidence());
+
+        CodeEdge implementsEdge = onlyEdge(result, EdgeKind.IMPLEMENTS);
+        assertNull(implementsEdge.getProperties().get("target_fqn"),
+                "MysteryAware has no source — solver fails — fallback");
+        assertNotEquals(Confidence.RESOLVED, implementsEdge.getConfidence());
+    }
+
+    // ── Helpers ──────────────────────────────────────────────────────────────
+
+    private Resolved bootstrapAndResolve(String relPath, String content) throws ResolutionException {
+        resolver.bootstrap(repoRoot);
+        DiscoveredFile file = new DiscoveredFile(Path.of(relPath), "java", content.length());
+        return resolver.resolve(file, content);
+    }
+
+    private DetectorContext ctxFor(String relPath, String content) {
+        return new DetectorContext(relPath, "java", content, null, null);
+    }
+
+    private static CodeEdge onlyEdge(DetectorResult result, EdgeKind kind) {
+        List<CodeEdge> matching = result.edges().stream()
+                .filter(e -> e.getKind() == kind)
+                .toList();
+        assertEquals(1, matching.size(),
+                "expected exactly one " + kind + " edge, got " + matching.size());
+        return matching.get(0);
+    }
+}