osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/java/kafka.py

@@ -0,0 +1,113 @@
+"""Kafka producer/consumer detector for Java source files."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_CLASS_RE = re.compile(r"(?:public\s+)?class\s+(\w+)")
+_KAFKA_LISTENER_RE = re.compile(
+    r'@KafkaListener\s*\(\s*(?:.*?topics?\s*=\s*)?[\{"]?\s*"([^"]+)"'
+)
+_KAFKA_SEND_RE = re.compile(
+    r'(?:kafkaTemplate|KafkaTemplate)\s*\.send\s*\(\s*"([^"]+)"'
+)
+_KAFKA_SEND_CONST_RE = re.compile(
+    r'(?:kafkaTemplate|KafkaTemplate)\s*\.send\s*\(\s*(\w+)'
+)
+_GROUP_ID_RE = re.compile(r'groupId\s*=\s*"([^"]+)"')
+
+
+class KafkaDetector:
+    """Detects Kafka consumers (@KafkaListener) and producers (KafkaTemplate.send)."""
+
+    name: str = "kafka"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        if "KafkaListener" not in text and "KafkaTemplate" not in text and "kafkaTemplate" not in text:
+            return result
+
+        # Find class name
+        class_name: str | None = None
+        for line in lines:
+            cm = _CLASS_RE.search(line)
+            if cm:
+                class_name = cm.group(1)
+                break
+
+        if not class_name:
+            return result
+
+        class_node_id = f"{ctx.file_path}:{class_name}"
+        seen_topics: set[str] = set()
+
+        def _ensure_topic_node(topic: str) -> str:
+            topic_id = f"kafka:topic:{topic}"
+            if topic not in seen_topics:
+                seen_topics.add(topic)
+                result.nodes.append(GraphNode(
+                    id=topic_id,
+                    kind=NodeKind.TOPIC,
+                    label=f"kafka:{topic}",
+                    properties={"broker": "kafka", "topic": topic},
+                ))
+            return topic_id
+
+        # Detect @KafkaListener consumers
+        for i, line in enumerate(lines):
+            m = _KAFKA_LISTENER_RE.search(line)
+            if not m:
+                # Multi-line annotation — check if previous line has @KafkaListener
+                if i > 0 and "@KafkaListener" in lines[i - 1]:
+                    m = re.search(r'"([^"]+)"', line)
+                if not m:
+                    continue
+
+            topic = m.group(1)
+            topic_id = _ensure_topic_node(topic)
+
+            group_id = _GROUP_ID_RE.search(line)
+            props: dict[str, str] = {"topic": topic}
+            if group_id:
+                props["group_id"] = group_id.group(1)
+
+            result.edges.append(GraphEdge(
+                source=class_node_id,
+                target=topic_id,
+                kind=EdgeKind.CONSUMES,
+                label=f"{class_name} consumes {topic}",
+                properties=props,
+            ))
+
+        # Detect KafkaTemplate.send producers
+        for i, line in enumerate(lines):
+            m = _KAFKA_SEND_RE.search(line)
+            if not m:
+                continue
+
+            topic = m.group(1)
+            topic_id = _ensure_topic_node(topic)
+
+            result.edges.append(GraphEdge(
+                source=class_node_id,
+                target=topic_id,
+                kind=EdgeKind.PRODUCES,
+                label=f"{class_name} produces to {topic}",
+                properties={"topic": topic},
+            ))
+
+        return result

osscodeiq/detectors/java/kafka_protocol.py

@@ -0,0 +1,70 @@
+"""Kafka protocol message detector for Java source files."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_PROTOCOL_MSG_RE = re.compile(
+    r"class\s+(\w+)\s+extends\s+(AbstractRequest|AbstractResponse)(?!\.)\b"
+)
+
+
+class KafkaProtocolDetector:
+    """Detects classes extending AbstractRequest or AbstractResponse — Kafka's binary protocol message pattern."""
+
+    name: str = "kafka_protocol"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        if "AbstractRequest" not in text and "AbstractResponse" not in text:
+            return result
+
+        lines = text.split("\n")
+
+        for i, line in enumerate(lines):
+            m = _PROTOCOL_MSG_RE.search(line)
+            if not m:
+                continue
+
+            class_name = m.group(1)
+            parent_class = m.group(2)
+            protocol_type = "request" if parent_class == "AbstractRequest" else "response"
+
+            node_id = f"{ctx.file_path}:{class_name}"
+
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.PROTOCOL_MESSAGE,
+                    label=class_name,
+                    location=SourceLocation(
+                        file_path=ctx.file_path,
+                        line_start=i + 1,
+                    ),
+                    properties={"protocol_type": protocol_type},
+                )
+            )
+
+            result.edges.append(
+                GraphEdge(
+                    source=node_id,
+                    target=f"*:{parent_class}",
+                    kind=EdgeKind.EXTENDS,
+                    label=f"{class_name} extends {parent_class}",
+                )
+            )
+
+        return result

osscodeiq/detectors/java/micronaut.py

@@ -0,0 +1,248 @@
+"""Micronaut framework detector for Java source files."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_CONTROLLER_RE = re.compile(r'@Controller\s*\(\s*"([^"]*)"')
+_HTTP_METHOD_RE = re.compile(r'@(Get|Post|Put|Delete)(?!Mapping)\s*(?:\(\s*"([^"]*)")?\s*\)?')
+_BEAN_SCOPE_RE = re.compile(r"@(Singleton|Prototype|Infrastructure)\b")
+_CLIENT_RE = re.compile(r'@Client\s*\(\s*"([^"]*)"')
+_INJECT_RE = re.compile(r"@Inject\b")
+_SCHEDULED_RE = re.compile(r'@Scheduled\s*\(\s*fixedRate\s*=\s*"([^"]+)"')
+_EVENT_LISTENER_RE = re.compile(r"@EventListener\b")
+_INJECT = "@Inject"
+_EVENT_LISTENER = "@EventListener"
+
+_CLASS_RE = re.compile(r"(?:public\s+)?class\s+(\w+)")
+_JAVA_METHOD_RE = re.compile(
+    r"(?:public|protected|private)?\s*(?:static\s+)?(?:[\w<>\[\],\s]+)\s+(\w+)\s*\("
+)
+
+
+class MicronautDetector:
+    """Detects Micronaut-specific patterns in Java source files."""
+
+    name: str = "micronaut"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Fast bail
+        if not any(
+            marker in text
+            for marker in (
+                "@Controller",
+                "@Get",
+                "@Post",
+                "@Put",
+                "@Delete",
+                "@Singleton",
+                "@Prototype",
+                "@Infrastructure",
+                "@Client",
+                _INJECT,
+                "@Scheduled",
+                _EVENT_LISTENER,
+                "io.micronaut",
+            )
+        ):
+            return result
+
+        lines = text.split("\n")
+
+        # Find class name and controller base path
+        class_name: str | None = None
+        controller_path: str | None = None
+        for i, line in enumerate(lines):
+            cm = _CLASS_RE.search(line)
+            if cm:
+                class_name = cm.group(1)
+                # Look backwards for @Controller
+                for j in range(max(0, i - 5), i):
+                    pm = _CONTROLLER_RE.search(lines[j])
+                    if pm:
+                        controller_path = pm.group(1).rstrip("/")
+                        break
+                break
+
+        class_node_id = f"{ctx.file_path}:{class_name}" if class_name else ctx.file_path
+
+        # If we found a @Controller, emit a CLASS node
+        if controller_path is not None and class_name:
+            ctrl_id = f"micronaut:{ctx.file_path}:controller:{class_name}"
+            result.nodes.append(
+                GraphNode(
+                    id=ctrl_id,
+                    kind=NodeKind.CLASS,
+                    label=f"@Controller({controller_path}) {class_name}",
+                    fqn=class_name,
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=1),
+                    annotations=["@Controller"],
+                    properties={"framework": "micronaut", "path": controller_path},
+                )
+            )
+
+        for i, line in enumerate(lines):
+            lineno = i + 1
+
+            # HTTP method annotations -> ENDPOINT
+            m = _HTTP_METHOD_RE.search(line)
+            if m:
+                http_method = m.group(1).upper()
+                method_path = m.group(2) or ""
+
+                # Build full path
+                if controller_path is not None:
+                    full_path = f"{controller_path}/{method_path.lstrip('/')}" if method_path else controller_path
+                else:
+                    full_path = f"/{method_path.lstrip('/')}" if method_path else "/"
+                if not full_path.startswith("/"):
+                    full_path = "/" + full_path
+
+                # Find method name
+                method_name: str | None = None
+                for k in range(i + 1, min(i + 5, len(lines))):
+                    mm = _JAVA_METHOD_RE.search(lines[k])
+                    if mm:
+                        method_name = mm.group(1)
+                        break
+
+                node_id = f"micronaut:{ctx.file_path}:endpoint:{http_method}:{full_path}:{lineno}"
+                endpoint_label = f"{http_method} {full_path}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.ENDPOINT,
+                        label=endpoint_label,
+                        fqn=f"{class_name}.{method_name}" if class_name and method_name else class_name,
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=[f"@{m.group(1)}"],
+                        properties={
+                            "framework": "micronaut",
+                            "http_method": http_method,
+                            "path": full_path,
+                        },
+                    )
+                )
+                result.edges.append(
+                    GraphEdge(
+                        source=class_node_id,
+                        target=node_id,
+                        kind=EdgeKind.EXPOSES,
+                        label=f"{class_name or 'class'} exposes {endpoint_label}",
+                    )
+                )
+
+            # Bean scope annotations -> MIDDLEWARE
+            m = _BEAN_SCOPE_RE.search(line)
+            if m:
+                scope = m.group(1)
+                node_id = f"micronaut:{ctx.file_path}:scope_{scope.lower()}:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.MIDDLEWARE,
+                        label=f"@{scope} (bean scope)",
+                        fqn=f"{class_name}.{scope}" if class_name else scope,
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=[f"@{scope}"],
+                        properties={"framework": "micronaut", "bean_scope": scope},
+                    )
+                )
+
+            # @Client -> DEPENDS_ON edge
+            m = _CLIENT_RE.search(line)
+            if m:
+                client_target = m.group(1)
+                client_id = f"micronaut:{ctx.file_path}:client:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=client_id,
+                        kind=NodeKind.CLASS,
+                        label=f"@Client({client_target})",
+                        fqn=client_target,
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=["@Client"],
+                        properties={"framework": "micronaut", "client_target": client_target},
+                    )
+                )
+                result.edges.append(
+                    GraphEdge(
+                        source=class_node_id,
+                        target=client_id,
+                        kind=EdgeKind.DEPENDS_ON,
+                        label=f"{class_name or 'class'} depends on {client_target}",
+                    )
+                )
+
+            # @Inject -> annotation node
+            m = _INJECT_RE.search(line)
+            if m:
+                node_id = f"micronaut:{ctx.file_path}:inject:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.MIDDLEWARE,
+                        label=_INJECT,
+                        fqn=f"{class_name}.inject" if class_name else "inject",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=[_INJECT],
+                        properties={"framework": "micronaut"},
+                    )
+                )
+
+            # @Scheduled -> EVENT
+            m = _SCHEDULED_RE.search(line)
+            if m:
+                rate = m.group(1)
+                node_id = f"micronaut:{ctx.file_path}:scheduled:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.EVENT,
+                        label=f"@Scheduled(fixedRate={rate})",
+                        fqn=f"{class_name}.scheduled" if class_name else "scheduled",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=["@Scheduled"],
+                        properties={"framework": "micronaut", "fixed_rate": rate},
+                    )
+                )
+
+            # @EventListener -> EVENT
+            m = _EVENT_LISTENER_RE.search(line)
+            if m:
+                node_id = f"micronaut:{ctx.file_path}:event_listener:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.EVENT,
+                        label=_EVENT_LISTENER,
+                        fqn=f"{class_name}.eventListener" if class_name else "eventListener",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=[_EVENT_LISTENER],
+                        properties={"framework": "micronaut"},
+                    )
+                )
+
+        return result

osscodeiq/detectors/java/module_deps.py

@@ -0,0 +1,191 @@
+"""Module dependency detector for Maven (pom.xml) and Gradle build files."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+from xml.etree import ElementTree
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_POM_NS = {"m": "http://maven.apache.org/POM/4.0.0"}
+
+# Gradle patterns
+_GRADLE_DEPENDENCY_RE = re.compile(
+    r"(?:implementation|api|compile|compileOnly|runtimeOnly|testImplementation)\s+"
+    r"(?:project\s*\(\s*['\"]([^'\"]+)['\"]\s*\)"
+    r"|['\"]([^'\"]+)['\"])"
+)
+_GRADLE_SETTINGS_MODULE_RE = re.compile(r"include\s+['\"]([^'\"]+)['\"]")
+
+
+class ModuleDepsDetector:
+    """Detects Maven/Gradle module declarations and inter-module dependencies."""
+
+    name: str = "module_deps"
+    supported_languages: tuple[str, ...] = ("java", "xml", "gradle")
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        if ctx.file_path.endswith("pom.xml"):
+            return self._detect_maven(ctx)
+        elif ctx.file_path.endswith((".gradle", ".gradle.kts")):
+            return self._detect_gradle(ctx)
+        elif ctx.file_path.endswith("settings.gradle") or ctx.file_path.endswith("settings.gradle.kts"):
+            return self._detect_gradle_settings(ctx)
+        return DetectorResult()
+
+    def _detect_maven(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        try:
+            root = ElementTree.fromstring(text)
+        except ElementTree.ParseError:
+            return result
+
+        # Determine this module's coordinates
+        # Try with namespace first, then without
+        group_id_el = root.find("m:groupId", _POM_NS)
+        if group_id_el is None:
+            group_id_el = root.find("groupId")
+        artifact_id_el = root.find("m:artifactId", _POM_NS)
+        if artifact_id_el is None:
+            artifact_id_el = root.find("artifactId")
+
+        if artifact_id_el is None:
+            return result
+
+        group_id = group_id_el.text if group_id_el is not None else "unknown"
+        artifact_id = artifact_id_el.text or "unknown"
+        module_id = f"module:{group_id}:{artifact_id}"
+
+        result.nodes.append(GraphNode(
+            id=module_id,
+            kind=NodeKind.MODULE,
+            label=artifact_id,
+            fqn=f"{group_id}:{artifact_id}",
+            module=ctx.module_name,
+            location=SourceLocation(file_path=ctx.file_path, line_start=1),
+            properties={"group_id": group_id, "artifact_id": artifact_id, "build_tool": "maven"},
+        ))
+
+        # Detect sub-modules
+        for modules_el in (root.findall("m:modules/m:module", _POM_NS) + root.findall("modules/module")):
+            if modules_el.text:
+                sub_module = modules_el.text
+                sub_id = f"module:{group_id}:{sub_module}"
+                result.nodes.append(GraphNode(
+                    id=sub_id,
+                    kind=NodeKind.MODULE,
+                    label=sub_module,
+                    fqn=f"{group_id}:{sub_module}",
+                    properties={"build_tool": "maven", "parent": artifact_id},
+                ))
+                result.edges.append(GraphEdge(
+                    source=module_id,
+                    target=sub_id,
+                    kind=EdgeKind.CONTAINS,
+                    label=f"{artifact_id} contains {sub_module}",
+                ))
+
+        # Detect dependencies
+        dep_paths = (
+            root.findall("m:dependencies/m:dependency", _POM_NS)
+            + root.findall("dependencies/dependency")
+        )
+        for dep in dep_paths:
+            dep_group_el = dep.find("m:groupId", _POM_NS)
+            if dep_group_el is None:
+                dep_group_el = dep.find("groupId")
+            dep_artifact_el = dep.find("m:artifactId", _POM_NS)
+            if dep_artifact_el is None:
+                dep_artifact_el = dep.find("artifactId")
+            if dep_artifact_el is not None:
+                dep_group = dep_group_el.text if dep_group_el is not None else "unknown"
+                dep_artifact = dep_artifact_el.text or "unknown"
+                dep_id = f"module:{dep_group}:{dep_artifact}"
+                result.edges.append(GraphEdge(
+                    source=module_id,
+                    target=dep_id,
+                    kind=EdgeKind.DEPENDS_ON,
+                    label=f"{artifact_id} depends on {dep_artifact}",
+                    properties={"group_id": dep_group, "artifact_id": dep_artifact},
+                ))
+
+        return result
+
+    def _detect_gradle(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        # Try to infer module name from file path
+        module_name = ctx.module_name or ctx.file_path.rsplit("/", 1)[0].rsplit("/", 1)[-1]
+        module_id = f"module:{module_name}"
+
+        result.nodes.append(GraphNode(
+            id=module_id,
+            kind=NodeKind.MODULE,
+            label=module_name,
+            fqn=module_name,
+            module=ctx.module_name,
+            location=SourceLocation(file_path=ctx.file_path, line_start=1),
+            properties={"build_tool": "gradle"},
+        ))
+
+        for i, line in enumerate(lines):
+            m = _GRADLE_DEPENDENCY_RE.search(line)
+            if not m:
+                continue
+
+            project_dep = m.group(1)  # project(':submodule')
+            external_dep = m.group(2)  # 'group:artifact:version'
+
+            if project_dep:
+                dep_name = project_dep.lstrip(":")
+                dep_id = f"module:{dep_name}"
+                result.edges.append(GraphEdge(
+                    source=module_id,
+                    target=dep_id,
+                    kind=EdgeKind.DEPENDS_ON,
+                    label=f"{module_name} depends on {dep_name}",
+                    properties={"type": "project"},
+                ))
+            elif external_dep and ":" in external_dep:
+                parts = external_dep.split(":")
+                dep_id = f"module:{parts[0]}:{parts[1]}" if len(parts) >= 2 else f"module:{external_dep}"
+                result.edges.append(GraphEdge(
+                    source=module_id,
+                    target=dep_id,
+                    kind=EdgeKind.DEPENDS_ON,
+                    label=f"{module_name} depends on {external_dep}",
+                    properties={"coordinate": external_dep, "type": "external"},
+                ))
+
+        return result
+
+    def _detect_gradle_settings(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        for m in _GRADLE_SETTINGS_MODULE_RE.finditer(text):
+            module_path = m.group(1).lstrip(":")
+            module_id = f"module:{module_path}"
+            result.nodes.append(GraphNode(
+                id=module_id,
+                kind=NodeKind.MODULE,
+                label=module_path,
+                fqn=module_path,
+                location=SourceLocation(file_path=ctx.file_path),
+                properties={"build_tool": "gradle"},
+            ))
+
+        return result