fix(detector): ModuleDepsDetector reaches settings.gradle branch

The dispatch chain in detect() checked `.endsWith(".gradle")` before the
settings-specific branch, so any `settings.gradle` / `settings.gradle.kts`
path routed to detectGradle() and the specialised detectGradleSettings()
helper was never reached. Gradle multi-module `include ':foo'` entries
were silently lost.

Reordered the dispatch so settings files are matched first, and added
ModuleDepsDetectorTest to lock in the reachability contract (plus a
regression guard that `build.gradle` still routes to detectGradle).

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

Author: aksOps

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

@@ -61,11 +61,16 @@ public DetectorResult detect(DetectorContext ctx) {
         String filePath = ctx.filePath();
         if (filePath.endsWith("pom.xml")) {
             return detectMaven(ctx);
-        } else if (filePath.endsWith(".gradle") || filePath.endsWith(".gradle.kts")) {
-            return detectGradle(ctx);
-        } else if (filePath.endsWith("settings.gradle") || filePath.endsWith("settings.gradle.kts")) {
+        }
+        // Order matters: `settings.gradle[.kts]` must be matched before the generic
+        // `.gradle[.kts]` branch, otherwise Gradle multi-module settings files are
+        // misrouted to detectGradle() and never reach detectGradleSettings().
+        if (filePath.endsWith("settings.gradle") || filePath.endsWith("settings.gradle.kts")) {
             return detectGradleSettings(ctx);
         }
+        if (filePath.endsWith(".gradle") || filePath.endsWith(".gradle.kts")) {
+            return detectGradle(ctx);
+        }
         return DetectorResult.empty();
     }
 

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

@@ -0,0 +1,165 @@
+package io.github.randomcodespace.iq.detector.jvm.java;
+
+import io.github.randomcodespace.iq.detector.DetectorContext;
+import io.github.randomcodespace.iq.detector.DetectorResult;
+import io.github.randomcodespace.iq.detector.DetectorTestUtils;
+import io.github.randomcodespace.iq.model.CodeNode;
+import io.github.randomcodespace.iq.model.NodeKind;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Unit tests for {@link ModuleDepsDetector}.
+ *
+ * <p>Focus: the dispatch chain in {@link ModuleDepsDetector#detect(DetectorContext)} must
+ * route {@code settings.gradle[.kts]} to {@code detectGradleSettings} and regular build
+ * scripts to {@code detectGradle}. The prior ordering checked {@code .endsWith(".gradle")}
+ * first, which shadowed the settings branch — tests below assert the fix holds.
+ */
+class ModuleDepsDetectorTest {
+
+    private final ModuleDepsDetector detector = new ModuleDepsDetector();
+
+    // ------------------------------------------------------------------
+    // Metadata
+    // ------------------------------------------------------------------
+
+    @Test
+    void getName_returnsModuleDeps() {
+        assertEquals("module_deps", detector.getName());
+    }
+
+    // ------------------------------------------------------------------
+    // Non-matching paths
+    // ------------------------------------------------------------------
+
+    @Test
+    void nonBuildFile_returnsEmpty() {
+        DetectorContext ctx = DetectorTestUtils.contextFor("src/Main.java", "java", "class Main {}");
+        DetectorResult r = detector.detect(ctx);
+        assertTrue(r.nodes().isEmpty());
+        assertTrue(r.edges().isEmpty());
+    }
+
+    // ------------------------------------------------------------------
+    // Gradle settings.gradle — the fixed branch
+    // ------------------------------------------------------------------
+
+    @Test
+    void settingsGradle_routesToDetectGradleSettings_andEmitsModuleNodes() {
+        // `include 'foo'` is only handled by detectGradleSettings.
+        // detectGradle (the generic .gradle branch) would emit zero nodes for this input,
+        // so seeing module nodes here proves the dispatch fix reaches detectGradleSettings.
+        String settings = """
+                rootProject.name = 'acme'
+                include ':api'
+                include ':domain'
+                include ':infra'
+                """;
+        DetectorContext ctx = DetectorTestUtils.contextFor("settings.gradle", "gradle", settings);
+        DetectorResult r = detector.detect(ctx);
+
+        assertThat(r.nodes())
+                .extracting(CodeNode::getLabel)
+                .containsExactlyInAnyOrder("api", "domain", "infra");
+        assertThat(r.nodes())
+                .allMatch(n -> n.getKind() == NodeKind.MODULE);
+        assertThat(r.nodes())
+                .allMatch(n -> "gradle".equals(n.getProperties().get("build_tool")));
+    }
+
+    @Test
+    void settingsGradleKts_routesToDetectGradleSettings() {
+        // The Kotlin-DSL syntax `include(":a")` is NOT matched by the detector's current
+        // regex (which expects a whitespace-separated call — `include ':a'`). This test
+        // asserts ONLY the dispatch contract: a `settings.gradle.kts` path reaches
+        // detectGradleSettings and, where the syntax is regex-compatible, produces module
+        // nodes. If the settings branch were still shadowed by the generic `.gradle` check,
+        // the `include ':b'` token below would not produce any module node.
+        String settingsKts = """
+                rootProject.name = "acme"
+                include ':b'
+                """;
+        DetectorContext ctx = DetectorTestUtils.contextFor("settings.gradle.kts", "gradle", settingsKts);
+        DetectorResult r = detector.detect(ctx);
+
+        assertThat(r.nodes())
+                .extracting(CodeNode::getLabel)
+                .contains("b");
+    }
+
+    @Test
+    void nestedSettingsGradlePath_stillRoutesToDetectGradleSettings() {
+        // Regression guard: path-like endsWith should still match when the settings file lives in a subdir.
+        String settings = "include ':core'\n";
+        DetectorContext ctx = DetectorTestUtils.contextFor("build/settings.gradle", "gradle", settings);
+        DetectorResult r = detector.detect(ctx);
+
+        assertThat(r.nodes())
+                .extracting(CodeNode::getLabel)
+                .containsExactly("core");
+    }
+
+    @Test
+    void settingsGradleEmpty_returnsEmpty() {
+        DetectorContext ctx = DetectorTestUtils.contextFor("settings.gradle", "gradle", "");
+        DetectorResult r = detector.detect(ctx);
+        assertTrue(r.nodes().isEmpty());
+    }
+
+    // ------------------------------------------------------------------
+    // Gradle build.gradle (non-settings) — must still use detectGradle
+    // ------------------------------------------------------------------
+
+    @Test
+    void buildGradle_routesToDetectGradle_notToSettings() {
+        // `include ':x'` outside settings.gradle should NOT produce module nodes — detectGradle
+        // parses dependencies, not settings includes. This guards against the symmetric mistake.
+        String build = """
+                dependencies {
+                    implementation project(':shared')
+                    implementation 'com.acme:lib:1.0.0'
+                }
+                """;
+        DetectorContext ctx = DetectorTestUtils.contextFor("build.gradle", "gradle", build);
+        DetectorResult r = detector.detect(ctx);
+
+        // detectGradle emits a module node for the current file plus DEPENDS_ON edges.
+        assertThat(r.nodes()).isNotEmpty();
+        assertThat(r.edges()).isNotEmpty();
+    }
+
+    // ------------------------------------------------------------------
+    // Maven
+    // ------------------------------------------------------------------
+
+    @Test
+    void pomXml_routesToDetectMaven() {
+        String pom = """
+                <project>
+                    <groupId>com.acme</groupId>
+                    <artifactId>orders</artifactId>
+                    <modules>
+                        <module>api</module>
+                    </modules>
+                </project>
+                """;
+        DetectorContext ctx = DetectorTestUtils.contextFor("pom.xml", "xml", pom);
+        DetectorResult r = detector.detect(ctx);
+        assertThat(r.nodes()).isNotEmpty();
+    }
+
+    // ------------------------------------------------------------------
+    // Determinism
+    // ------------------------------------------------------------------
+
+    @Test
+    void deterministic_settingsGradle() {
+        String settings = "include ':a'\ninclude ':b'\n";
+        DetectorContext ctx = DetectorTestUtils.contextFor("settings.gradle", "gradle", settings);
+        DetectorTestUtils.assertDeterministic(detector, ctx);
+    }
+}