feat: JVM module discovery and package-declaration index (issue-2, PR 1/3) (#30)

Author: NehharShah

.DS_Store

@@ -33,6 +33,11 @@
 # Built-in path roots that can never be workspace crates. `self`/`super` are
 # relative module paths; `crate::` paths are resolved dir-level below.
 RUST_SKIP = {"std", "core", "alloc", "crate", "self", "super"}
+# JVM: a Maven/Gradle module is any dir carrying its own build file.
+JVM_BUILD_FILES = ("pom.xml", "build.gradle", "build.gradle.kts")
+# `package a.b.c;` (Java) / `package a.b.c` (Kotlin, no semicolon).
+JVM_PACKAGE_RE = re.compile(r"^\s*package\s+([A-Za-z_][\w.]*)\s*;?\s*$", re.M)
+JVM_EXTS = (".java", ".kt")
 
 
 def collect(repo, tree=None):
@@ -249,6 +254,35 @@ def _rust_resolve(src_root, segments, tree):
     return target
 
 
+# -- Java / Kotlin -----------------------------------------------------------
+
+def _jvm_modules(tree):
+    """Dirs that are Maven/Gradle modules (each submodule carries its own
+    build file, so no settings.gradle / <modules> parsing is needed)."""
+    return sorted(rel for rel, files in tree.items()
+                  if any(b in files for b in JVM_BUILD_FILES))
+
+
+def _jvm_package_index(repo, tree):
+    """{package name -> set of dirs declaring it}, from `package` declarations.
+
+    Declarations are language-level ground truth: they work for standard
+    src/main/java layouts, Kotlin's collapsed directory convention, and plain
+    src/ repos with no build files at all. Imports (follow-up PR) resolve
+    against this index by longest package prefix, which makes external
+    imports (java.*, kotlin.*, third-party) drop out naturally.
+    """
+    index = {}
+    for rel, files in tree.items():
+        for f in files:
+            if not f.endswith(JVM_EXTS):
+                continue
+            m = JVM_PACKAGE_RE.search(_read(repo, rel, f))
+            if m:
+                index.setdefault(m.group(1), set()).add(rel)
+    return index
+
+
 # -- helpers -----------------------------------------------------------------
 
 def _norm(p):

src/repokg/deps.py

@@ -0,0 +1,63 @@
+import os
+import tempfile
+import unittest
+
+from repokg.code import walk
+from repokg.deps import _jvm_modules, _jvm_package_index
+
+
+def write(root, rel, text):
+    path = os.path.join(root, rel)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(text)
+
+
+class TestJVMDiscovery(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.repo = self.tmp.name
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def tree(self):
+        return dict(walk(self.repo))
+
+    def test_maven_and_gradle_modules(self):
+        write(self.repo, "pom.xml", "<project/>")
+        write(self.repo, "core/pom.xml", "<project/>")
+        write(self.repo, "api/build.gradle", "")
+        write(self.repo, "app/build.gradle.kts", "")
+        write(self.repo, "docs/readme.txt", "")
+        self.assertEqual(_jvm_modules(self.tree()), ["", "api", "app", "core"])
+
+    def test_package_index_java_and_kotlin(self):
+        write(self.repo, "core/src/main/java/com/acme/core/Engine.java",
+              "// (c) acme\npackage com.acme.core;\n\npublic class Engine {}\n")
+        write(self.repo, "core/src/main/java/com/acme/core/util/Str.java",
+              "package com.acme.core.util;\nclass Str {}\n")
+        # Kotlin: no semicolon, collapsed dir convention (dir != package path)
+        write(self.repo, "api/src/main/kotlin/Handlers.kt",
+              "package com.acme.api\n\nfun handle() {}\n")
+        idx = _jvm_package_index(self.repo, self.tree())
+        self.assertEqual(idx["com.acme.core"],
+                         {"core/src/main/java/com/acme/core"})
+        self.assertEqual(idx["com.acme.core.util"],
+                         {"core/src/main/java/com/acme/core/util"})
+        self.assertEqual(idx["com.acme.api"], {"api/src/main/kotlin"})
+
+    def test_javadoc_and_comments_not_mistaken_for_declarations(self):
+        write(self.repo, "src/A.java",
+              "/**\n * package fake.name\n */\npackage real.pkg;\nclass A {}\n")
+        write(self.repo, "src/B.java", "// package another.fake\nclass B {}\n")
+        idx = _jvm_package_index(self.repo, self.tree())
+        self.assertEqual(set(idx), {"real.pkg"})
+
+    def test_default_package_files_ignored(self):
+        write(self.repo, "src/Main.java", "public class Main {}\n")
+        self.assertEqual(_jvm_package_index(self.repo, self.tree()), {})
+
+
+if __name__ == "__main__":
+    unittest.main()