fix(detection): address CTO code review — 5 issues from PR #20

1. ConfigDefDetector: move seenKeys to file scope to prevent duplicate
   config nodes when multiple classes in the same file reference the same
   @value or ConfigDef key.

2. ReactComponentDetector: tighten RENDERS filter from allDetected to
   self-only guard (!tag.equals(comp.name())). Sibling components in the
   same file now correctly create RENDERS edges (Header → Footer was
   previously silently dropped).

3. KafkaDetector: extend CLASS_RE to handle Kotlin modifiers (data class,
   internal class, abstract class, open class, sealed class, object).
   Previously only matched plain Java-style `class Foo`.

4. ConfigDefDetector: add receiver discriminator to .define() call
   matching. Only flags calls where the scope references "ConfigDef" or
   "CONFIG" — prevents false positives from unrelated .define() calls
   in files that happen to import ConfigDef.

5. TopicLinker: add determinism test covering multi-sender/multi-receiver
   SENDS_TO/RECEIVES_FROM scenarios (sorted iteration requirement).

All 108 targeted Java tests pass (0 failures).

Co-Authored-By: Paperclip <noreply@paperclip.ing>

Author: aksOps

src/main/java/io/github/randomcodespace/iq/detector/frontend/ReactComponentDetector.java

@@ -130,9 +130,8 @@ record ComponentEntry(String name, String sourceId, int matchStart) {}
 
         // RENDERS edges: scope JSX tag search to each component's body section.
         // A component's body is from its match position to the next component's position.
-        Set<String> allDetected = new HashSet<>(componentNames);
-        allDetected.addAll(hookNames);
-
+        // Filter: only exclude self-renders. Sibling components defined in the same file
+        // are allowed — they represent real inter-component RENDERS relationships.
         componentEntries.sort(Comparator.comparingInt(ComponentEntry::matchStart));
 
         for (int i = 0; i < componentEntries.size(); i++) {
@@ -147,7 +146,7 @@ record ComponentEntry(String name, String sourceId, int matchStart) {}
             Matcher jsxM = JSX_TAG.matcher(bodyText);
             while (jsxM.find()) {
                 String tag = jsxM.group(1);
-                if (!allDetected.contains(tag)) {
+                if (!tag.equals(comp.name())) {
                     childNames.add(tag);
                 }
             }

src/main/java/io/github/randomcodespace/iq/detector/java/ConfigDefDetector.java

@@ -80,16 +80,28 @@ public DetectorResult detect(DetectorContext ctx) {
     private DetectorResult detectWithAst(CompilationUnit cu, DetectorContext ctx) {
         List<CodeNode> nodes = new ArrayList<>();
         List<CodeEdge> edges = new ArrayList<>();
+        // File-scoped seenKeys prevents duplicate config nodes when multiple classes
+        // in the same file reference the same key (e.g., @Value("${server.port}")).
+        Set<String> seenKeys = new LinkedHashSet<>();
 
         cu.findAll(ClassOrInterfaceDeclaration.class).forEach(classDecl -> {
             String className = classDecl.getNameAsString();
             String classNodeId = ctx.filePath() + ":" + className;
-            Set<String> seenKeys = new LinkedHashSet<>();
 
             // 1. Kafka ConfigDef.define() calls
+            // Discriminator: receiver must mention "ConfigDef" or "CONFIG" to avoid matching
+            // unrelated .define() calls (per CLAUDE.md: framework detectors must have guards).
             classDecl.findAll(MethodCallExpr.class).forEach(call -> {
                 if (!"define".equals(call.getNameAsString())) return;
                 if (call.getArguments().isEmpty()) return;
+                // Receiver check: scope must reference a ConfigDef instance or chain
+                boolean receiverIsConfigDef = call.getScope()
+                        .map(scope -> {
+                            String s = scope.toString();
+                            return s.contains("ConfigDef") || s.toUpperCase().contains("CONFIG");
+                        })
+                        .orElse(false);
+                if (!receiverIsConfigDef) return;
                 var firstArg = call.getArguments().get(0);
                 if (!firstArg.isStringLiteralExpr()) return;
                 String configKey = firstArg.asStringLiteralExpr().getValue();

src/main/java/io/github/randomcodespace/iq/detector/java/KafkaDetector.java

@@ -29,7 +29,12 @@
 @Component
 public class KafkaDetector extends AbstractRegexDetector {
 
-    private static final Pattern CLASS_RE = Pattern.compile("(?:public\\s+)?class\\s+(\\w+)");
+    // Matches Java: `public class Foo`, `class Foo`
+    // Matches Kotlin: `class Foo`, `data class Foo`, `abstract class Foo`, `internal class Foo`,
+    //                 `open class Foo`, `sealed class Foo`, `object Foo` (Kotlin singleton)
+    private static final Pattern CLASS_RE = Pattern.compile(
+            "(?:(?:public|internal|private|protected|data|abstract|open|sealed|enum|inline|value)\\s+)*" +
+            "(?:class|object)\\s+(\\w+)");
     private static final Pattern KAFKA_LISTENER_RE = Pattern.compile(
             "@KafkaListener\\s*\\(\\s*(?:.*?topics?\\s*=\\s*)?[\\{\"]?\\s*\"([^\"]+)\"");
     private static final Pattern KAFKA_SEND_RE = Pattern.compile(

src/test/java/io/github/randomcodespace/iq/analyzer/linker/TopicLinkerTest.java

@@ -161,4 +161,38 @@ void handlesQueueNodes() {
 
         assertEquals(1, result.edges().size());
     }
+
+    @Test
+    void isDeterministicWithSendToReceivesFrom() {
+        var topic = new CodeNode("topic:invoices", NodeKind.TOPIC, "invoices");
+        var sender1 = new CodeNode("svc:InvoiceService", NodeKind.CLASS, "InvoiceService");
+        var sender2 = new CodeNode("svc:BillingService", NodeKind.CLASS, "BillingService");
+        var receiver1 = new CodeNode("svc:AuditService", NodeKind.CLASS, "AuditService");
+        var receiver2 = new CodeNode("svc:ArchiveService", NodeKind.CLASS, "ArchiveService");
+
+        var e1 = new CodeEdge(); e1.setId("e1"); e1.setKind(EdgeKind.SENDS_TO);
+        e1.setSourceId("svc:InvoiceService"); e1.setTarget(topic);
+
+        var e2 = new CodeEdge(); e2.setId("e2"); e2.setKind(EdgeKind.SENDS_TO);
+        e2.setSourceId("svc:BillingService"); e2.setTarget(topic);
+
+        var e3 = new CodeEdge(); e3.setId("e3"); e3.setKind(EdgeKind.RECEIVES_FROM);
+        e3.setSourceId("svc:AuditService"); e3.setTarget(topic);
+
+        var e4 = new CodeEdge(); e4.setId("e4"); e4.setKind(EdgeKind.RECEIVES_FROM);
+        e4.setSourceId("svc:ArchiveService"); e4.setTarget(topic);
+
+        List<CodeNode> nodes = List.of(topic, sender1, sender2, receiver1, receiver2);
+        List<CodeEdge> edges = List.of(e1, e2, e3, e4);
+
+        LinkResult r1 = linker.link(nodes, edges);
+        LinkResult r2 = linker.link(nodes, edges);
+
+        assertEquals(r1.edges().size(), r2.edges().size(), "Edge count must be deterministic");
+        List<String> ids1 = r1.edges().stream().map(CodeEdge::getId).sorted().toList();
+        List<String> ids2 = r2.edges().stream().map(CodeEdge::getId).sorted().toList();
+        assertEquals(ids1, ids2, "Edge IDs must be deterministic");
+        // 2 senders × 2 receivers = 4 CALLS edges
+        assertEquals(4, r1.edges().size());
+    }
 }

src/test/java/io/github/randomcodespace/iq/detector/frontend/ReactComponentDetectorTest.java

@@ -66,6 +66,27 @@ void rendersEdgesScopedToCorrectComponent() {
         assertFalse(footerRenders.contains("Button"), "Footer should NOT render Button");
     }
 
+    @Test
+    void siblingComponentRendersEdgeIsNotDropped() {
+        // Header renders Footer (both in same file). Previously dropped by allDetected filter.
+        String source = """
+                export const Header = () => {
+                  return <div><Footer /></div>;
+                };
+
+                export const Footer = () => {
+                  return <div>footer</div>;
+                };
+                """;
+        DetectorResult r = d.detect(DetectorTestUtils.contextFor("typescript", source));
+        assertEquals(2, r.nodes().size());
+        List<String> headerRenders = r.edges().stream()
+                .filter(e -> e.getKind() == EdgeKind.RENDERS && e.getSourceId().contains("Header"))
+                .map(e -> e.getTarget().getId())
+                .toList();
+        assertTrue(headerRenders.contains("Footer"), "Header should RENDERS Footer (sibling component)");
+    }
+
     @Test
     void singleComponentGetsAllJsxTags() {
         String source = """

src/test/java/io/github/randomcodespace/iq/detector/java/JavaDetectorsTest.java

@@ -395,6 +395,34 @@ fun consume(msg: String) {}
             assertTrue(r.edges().stream().anyMatch(e -> e.getKind().getValue().equals("consumes")));
         }
 
+        @Test
+        void detectsKotlinDataClassKafkaListener() {
+            // data class and internal class modifiers must be handled by CLASS_RE
+            String kotlinSample = """
+                    internal data class OrderConsumer(val kafkaTemplate: Any) {
+                        @KafkaListener(topics = "payments")
+                        fun onPayment(msg: String) {}
+                    }
+                    """;
+            var r = new KafkaDetector().detect(ctx("kotlin", kotlinSample));
+            assertFalse(r.nodes().isEmpty());
+            assertTrue(r.edges().stream().anyMatch(e -> e.getKind().getValue().equals("consumes")));
+        }
+
+        @Test
+        void detectsKotlinObjectKafkaTemplate() {
+            // Kotlin object (singleton) is a common pattern for producer utilities
+            String kotlinSample = """
+                    object EventPublisher {
+                        lateinit var kafkaTemplate: KafkaTemplate<String, String>
+                        fun publish() { kafkaTemplate.send("events", "data") }
+                    }
+                    """;
+            var r = new KafkaDetector().detect(ctx("kotlin", kotlinSample));
+            assertFalse(r.nodes().isEmpty());
+            assertTrue(r.edges().stream().anyMatch(e -> e.getKind().getValue().equals("produces")));
+        }
+
         @Test
         void detectsKotlinKafkaTemplate() {
             String kotlinSample = """
@@ -742,6 +770,37 @@ public class Cfg {
                     """;
             DetectorTestUtils.assertDeterministic(new ConfigDefDetector(), ctx("java", sample));
         }
+
+        @Test
+        void genericDefineCallDoesNotFalsePositive() {
+            // A file containing "ConfigDef" text but calling .define() on an unrelated receiver
+            // must NOT produce config nodes (discriminator guard).
+            String sample = """
+                    import org.apache.kafka.common.config.ConfigDef;
+                    public class Schema {
+                        // this define() is on a Schema builder, not ConfigDef
+                        void setup() { schema.define("field", Type.STRING); }
+                    }
+                    """;
+            var r = new ConfigDefDetector().detect(ctx("java", sample));
+            assertTrue(r.nodes().isEmpty(), "schema.define() should not match — receiver is not ConfigDef");
+        }
+
+        @Test
+        void kafkaConfigDefWithReceiverMatches() {
+            String sample = """
+                    import org.apache.kafka.common.config.ConfigDef;
+                    public class MyConfig {
+                        static final ConfigDef CONFIG = new ConfigDef()
+                            .define("batch.size", ConfigDef.Type.INT, 1000)
+                            .define("timeout.ms", ConfigDef.Type.LONG, 5000L);
+                    }
+                    """;
+            var r = new ConfigDefDetector().detect(ctx("java", sample));
+            assertEquals(2, r.nodes().size());
+            assertTrue(r.nodes().stream().anyMatch(n -> n.getLabel().equals("batch.size")));
+            assertTrue(r.nodes().stream().anyMatch(n -> n.getLabel().equals("timeout.ms")));
+        }
     }
 
     // ==================== ModuleDepsDetector ====================