osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/kotlin/kotlin_structures.py

@@ -0,0 +1,124 @@
+"""Regex-based Kotlin structures detector for Kotlin source files."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text, find_line_number
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+# FIX: Added sealed, enum, annotation, value, inline modifiers (original only
+# had data, open, abstract).
+_KOTLIN_IMPORT_RE = re.compile(r'^\s*import\s+([\w.]+)', re.MULTILINE)
+_KOTLIN_CLASS_RE = re.compile(
+    r'^\s*(?:(?:data|open|abstract|sealed|enum|annotation|value|inline)\s+)*class\s+(\w+)'
+    r'(?:\s*(?:\(.*?\))?\s*:\s*([\w\s,.<>]+))?',
+    re.MULTILINE,
+)
+_KOTLIN_INTERFACE_RE = re.compile(r'^\s*interface\s+(\w+)', re.MULTILINE)
+# FIX: Added inline fun and override fun matching (original missed inline fun).
+_KOTLIN_FUN_RE = re.compile(
+    r'^\s*(?:(?:override|inline|private|protected|internal|public)\s+)*(?:fun|suspend\s+fun)\s+(\w+)\s*\(',
+    re.MULTILINE,
+)
+_KOTLIN_OBJECT_RE = re.compile(r'^\s*object\s+(\w+)', re.MULTILINE)
+
+
+
+class KotlinStructuresDetector:
+    """Detects Kotlin imports, classes, interfaces, objects, and functions."""
+
+    name: str = "kotlin_structures"
+    supported_languages: tuple[str, ...] = ("kotlin",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        file_node_id = ctx.file_path
+
+        for m in _KOTLIN_IMPORT_RE.finditer(text):
+            target = m.group(1)
+            result.edges.append(GraphEdge(
+                source=file_node_id,
+                target=target,
+                kind=EdgeKind.IMPORTS,
+                label=f"{ctx.file_path} imports {target}",
+            ))
+
+        for m in _KOTLIN_CLASS_RE.finditer(text):
+            class_name = m.group(1)
+            supertypes_str = m.group(2)
+            node_id = f"{ctx.file_path}:{class_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.CLASS,
+                label=class_name,
+                fqn=class_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+            ))
+            if supertypes_str:
+                for st in supertypes_str.split(","):
+                    st = st.strip().split("(")[0].split("<")[0].strip()
+                    if st:
+                        result.edges.append(GraphEdge(
+                            source=node_id,
+                            target=st,
+                            kind=EdgeKind.EXTENDS,
+                            label=f"{class_name} extends {st}",
+                        ))
+
+        for m in _KOTLIN_INTERFACE_RE.finditer(text):
+            iface_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{iface_name}",
+                kind=NodeKind.INTERFACE,
+                label=iface_name,
+                fqn=iface_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+            ))
+
+        for m in _KOTLIN_OBJECT_RE.finditer(text):
+            obj_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{obj_name}",
+                kind=NodeKind.CLASS,
+                label=obj_name,
+                fqn=obj_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties={"type": "object"},
+            ))
+
+        for m in _KOTLIN_FUN_RE.finditer(text):
+            fn_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{fn_name}",
+                kind=NodeKind.METHOD,
+                label=fn_name,
+                fqn=fn_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+            ))
+
+        return result

osscodeiq/detectors/kotlin/ktor_routes.py

@@ -0,0 +1,163 @@
+"""Ktor route detector for Kotlin."""
+
+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 GraphEdge, GraphNode, NodeKind, SourceLocation
+
+
+class KtorRouteDetector:
+    """Detects Ktor route definitions, routing blocks, install plugins, and authenticate guards."""
+
+    name: str = "ktor_routes"
+    supported_languages: tuple[str, ...] = ("kotlin",)
+
+    # get("/path") { ... } or post("/path") { ... }
+    _ENDPOINT_PATTERN = re.compile(
+        r"\b(get|post|put|delete|patch)\(\s*\"([^\"]+)\"\s*\)\s*\{"
+    )
+
+    # routing { ... } block
+    _ROUTING_PATTERN = re.compile(r"\brouting\s*\{")
+
+    # route("/prefix") { ... } for nested route prefixes
+    _ROUTE_PREFIX_PATTERN = re.compile(
+        r"\broute\(\s*\"([^\"]+)\"\s*\)\s*\{"
+    )
+
+    # install(FeatureName) { ... }
+    _INSTALL_PATTERN = re.compile(
+        r"\binstall\(\s*(\w+)\s*\)"
+    )
+
+    # authenticate("auth-name") { ... }
+    _AUTHENTICATE_PATTERN = re.compile(
+        r"\bauthenticate\(\s*\"([^\"]+)\"\s*\)\s*\{"
+    )
+
+    def _build_prefix_map(self, text: str) -> dict[int, str]:
+        """Build a map of line numbers to their accumulated route prefixes.
+
+        Tracks route() nesting by scanning open/close braces within route blocks.
+        """
+        prefixes: dict[int, str] = {}
+        active_prefixes: list[tuple[str, int]] = []  # (prefix, brace_depth)
+        brace_depth = 0
+
+        for i, line in enumerate(text.split("\n"), 1):
+            # Track brace depth
+            brace_depth += line.count("{") - line.count("}")
+
+            # Check for route prefix opening
+            route_match = self._ROUTE_PREFIX_PATTERN.search(line)
+            if route_match:
+                active_prefixes.append((route_match.group(1), brace_depth))
+
+            # Remove prefixes whose scope has closed
+            while active_prefixes and brace_depth < active_prefixes[-1][1]:
+                active_prefixes.pop()
+
+            # Build the combined prefix for this line
+            if active_prefixes:
+                prefixes[i] = "".join(p for p, _ in active_prefixes)
+
+        return prefixes
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        prefix_map = self._build_prefix_map(text)
+
+        # Detect routing { } blocks as MODULE nodes
+        for match in self._ROUTING_PATTERN.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"ktor:{ctx.file_path}:routing:{line}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.MODULE,
+                    label="routing",
+                    fqn=f"{ctx.file_path}::routing",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "framework": "ktor",
+                        "type": "router",
+                    },
+                )
+            )
+
+        # Detect endpoint definitions: get("/path") { ... }
+        for match in self._ENDPOINT_PATTERN.finditer(text):
+            method = match.group(1).upper()
+            raw_path = match.group(2)
+            line = text[: match.start()].count("\n") + 1
+
+            # Prepend any accumulated route prefix
+            prefix = prefix_map.get(line, "")
+            path = prefix + raw_path
+
+            node_id = f"ktor:{ctx.file_path}:{method}:{path}:{line}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.ENDPOINT,
+                    label=f"{method} {path}",
+                    fqn=f"{ctx.file_path}::{method}:{path}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "protocol": "REST",
+                        "http_method": method,
+                        "path_pattern": path,
+                        "framework": "ktor",
+                    },
+                )
+            )
+
+        # Detect install(Feature) as MIDDLEWARE
+        for match in self._INSTALL_PATTERN.finditer(text):
+            feature_name = match.group(1)
+            line = text[: match.start()].count("\n") + 1
+
+            node_id = f"ktor:{ctx.file_path}:install:{feature_name}:{line}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.MIDDLEWARE,
+                    label=f"install:{feature_name}",
+                    fqn=f"{ctx.file_path}::install:{feature_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "framework": "ktor",
+                        "feature": feature_name,
+                    },
+                )
+            )
+
+        # Detect authenticate("name") { ... } as GUARD
+        for match in self._AUTHENTICATE_PATTERN.finditer(text):
+            auth_name = match.group(1)
+            line = text[: match.start()].count("\n") + 1
+
+            node_id = f"ktor:{ctx.file_path}:auth:{auth_name}:{line}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.GUARD,
+                    label=f"authenticate:{auth_name}",
+                    fqn=f"{ctx.file_path}::authenticate:{auth_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "framework": "ktor",
+                        "auth_name": auth_name,
+                    },
+                )
+            )
+
+        return result

osscodeiq/detectors/proto/proto_structure.py

@@ -0,0 +1,153 @@
+"""Protocol Buffers structure detector for services, RPCs, and messages."""
+
+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,
+)
+
+_SERVICE_RE = re.compile(r'service\s+(\w+)\s*\{')
+_RPC_RE = re.compile(r'rpc\s+(\w+)\s*\((\w+)\)\s*returns\s*\((\w+)\)')
+_MESSAGE_RE = re.compile(r'message\s+(\w+)\s*\{')
+_IMPORT_RE = re.compile(r'import\s+"([^"]+)"')
+_PACKAGE_RE = re.compile(r'package\s+([\w.]+)\s*;')
+
+
+class ProtoStructureDetector:
+    """Detects Protobuf services, RPCs, messages, imports, and package declarations."""
+
+    name: str = "proto_structure"
+    supported_languages: tuple[str, ...] = ("proto",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        try:
+            text = decode_text(ctx)
+        except Exception:
+            return result
+
+        filepath = ctx.file_path
+        lines = text.split("\n")
+
+        # Package declaration
+        for i, line in enumerate(lines):
+            m = _PACKAGE_RE.search(line)
+            if m:
+                pkg_name = m.group(1)
+                result.nodes.append(GraphNode(
+                    id=f"proto:{filepath}:package:{pkg_name}",
+                    kind=NodeKind.CONFIG_KEY,
+                    label=f"package {pkg_name}",
+                    fqn=pkg_name,
+                    module=ctx.module_name,
+                    location=SourceLocation(
+                        file_path=filepath,
+                        line_start=i + 1,
+                    ),
+                    properties={"package": pkg_name},
+                ))
+                break
+
+        # Imports
+        for i, line in enumerate(lines):
+            m = _IMPORT_RE.search(line)
+            if m:
+                import_path = m.group(1)
+                result.edges.append(GraphEdge(
+                    source=filepath,
+                    target=import_path,
+                    kind=EdgeKind.IMPORTS,
+                    label=f"{filepath} imports {import_path}",
+                ))
+
+        # Services and RPCs — track current service for RPC scoping
+        current_service: str | None = None
+        brace_depth = 0
+
+        for i, line in enumerate(lines):
+            # Track service blocks
+            svc_match = _SERVICE_RE.search(line)
+            if svc_match:
+                svc_name = svc_match.group(1)
+                current_service = svc_name
+                brace_depth = 0
+
+                result.nodes.append(GraphNode(
+                    id=f"proto:{filepath}:service:{svc_name}",
+                    kind=NodeKind.INTERFACE,
+                    label=svc_name,
+                    fqn=svc_name,
+                    module=ctx.module_name,
+                    location=SourceLocation(
+                        file_path=filepath,
+                        line_start=i + 1,
+                    ),
+                ))
+
+            # Track braces for service scope
+            if current_service is not None:
+                brace_depth += line.count("{") - line.count("}")
+                if brace_depth <= 0:
+                    current_service = None
+
+            # RPCs
+            rpc_match = _RPC_RE.search(line)
+            if rpc_match:
+                method_name = rpc_match.group(1)
+                request_type = rpc_match.group(2)
+                response_type = rpc_match.group(3)
+                svc = current_service or "_unknown"
+
+                rpc_id = f"proto:{filepath}:rpc:{svc}:{method_name}"
+                result.nodes.append(GraphNode(
+                    id=rpc_id,
+                    kind=NodeKind.METHOD,
+                    label=f"{svc}.{method_name}",
+                    fqn=f"{svc}.{method_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(
+                        file_path=filepath,
+                        line_start=i + 1,
+                    ),
+                    properties={
+                        "request_type": request_type,
+                        "response_type": response_type,
+                    },
+                ))
+
+                # RPC belongs to service
+                if current_service:
+                    result.edges.append(GraphEdge(
+                        source=f"proto:{filepath}:service:{current_service}",
+                        target=rpc_id,
+                        kind=EdgeKind.CONTAINS,
+                        label=f"{current_service} contains {method_name}",
+                    ))
+
+        # Messages
+        for i, line in enumerate(lines):
+            m = _MESSAGE_RE.search(line)
+            if m:
+                msg_name = m.group(1)
+                result.nodes.append(GraphNode(
+                    id=f"proto:{filepath}:message:{msg_name}",
+                    kind=NodeKind.PROTOCOL_MESSAGE,
+                    label=msg_name,
+                    fqn=msg_name,
+                    module=ctx.module_name,
+                    location=SourceLocation(
+                        file_path=filepath,
+                        line_start=i + 1,
+                    ),
+                ))
+
+        return result

osscodeiq/detectors/python/celery_tasks.py

@@ -0,0 +1,88 @@
+"""Celery task detector."""
+
+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 CeleryTaskDetector:
+    """Detects Celery task definitions and task invocations."""
+
+    name: str = "python.celery_tasks"
+    supported_languages: tuple[str, ...] = ("python",)
+
+    # @app.task or @shared_task or @celery.task
+    _TASK_DECORATOR = re.compile(
+        r"@(?:\w+\.)?(?:task|shared_task)\(?"
+        r"(?:.*?name\s*=\s*['\"]([^'\"]+)['\"])?"
+        r"[^)]*\)?\s*\n\s*def\s+(\w+)",
+        re.DOTALL,
+    )
+
+    # task.delay(...) or task.apply_async(...)
+    _TASK_CALL = re.compile(
+        r"(\w+)\.(delay|apply_async|s|si|signature)\("
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Detect task definitions (these are like queue consumers)
+        for match in self._TASK_DECORATOR.finditer(text):
+            task_name = match.group(1) or match.group(2)
+            func_name = match.group(2)
+            line = text[:match.start()].count("\n") + 1
+
+            # Create a queue node for the task
+            queue_id = f"queue:{ctx.module_name or ''}:celery:{task_name}"
+            result.nodes.append(GraphNode(
+                id=queue_id,
+                kind=NodeKind.QUEUE,
+                label=f"celery:{task_name}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                properties={
+                    "broker": "celery",
+                    "task_name": task_name,
+                    "function": func_name,
+                },
+            ))
+
+            # The task function consumes from this queue
+            method_id = f"method:{ctx.file_path}::{func_name}"
+            result.nodes.append(GraphNode(
+                id=method_id,
+                kind=NodeKind.METHOD,
+                label=func_name,
+                fqn=f"{ctx.file_path}::{func_name}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+            ))
+            result.edges.append(GraphEdge(
+                source=method_id,
+                target=queue_id,
+                kind=EdgeKind.CONSUMES,
+                label="celery_task",
+            ))
+
+        # Detect task invocations (producers)
+        for match in self._TASK_CALL.finditer(text):
+            task_ref = match.group(1)
+            call_type = match.group(2)
+            line = text[:match.start()].count("\n") + 1
+
+            queue_id = f"queue:{ctx.module_name or ''}:celery:{task_ref}"
+            caller_id = f"method:{ctx.file_path}::caller_l{line}"
+            result.edges.append(GraphEdge(
+                source=caller_id,
+                target=queue_id,
+                kind=EdgeKind.PRODUCES,
+                label=f"{task_ref}.{call_type}",
+            ))
+
+        return result

osscodeiq/detectors/python/django_auth.py

@@ -0,0 +1,132 @@
+"""Django authentication and authorization detector for Python 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 GraphNode, NodeKind, SourceLocation
+
+# @login_required
+_LOGIN_REQUIRED_RE = re.compile(r'@login_required\b')
+
+# @permission_required("app.can_edit") or @permission_required("app.can_edit", ...)
+_PERMISSION_REQUIRED_RE = re.compile(
+    r'@permission_required\(\s*["\']([^"\']*)["\']'
+)
+
+# @user_passes_test(some_func) or @user_passes_test(lambda u: u.is_staff)
+_USER_PASSES_TEST_RE = re.compile(
+    r'@user_passes_test\(\s*([^,)\s]+)'
+)
+
+# class MyView(LoginRequiredMixin, ...):
+# class MyView(PermissionRequiredMixin, ...):
+# class MyView(UserPassesTestMixin, ...):
+_MIXIN_RE = re.compile(
+    r'class\s+(\w+)\s*\(([^)]*)\):'
+)
+
+_AUTH_MIXINS = {
+    "LoginRequiredMixin": "login_required",
+    "PermissionRequiredMixin": "permission_required",
+    "UserPassesTestMixin": "user_passes_test",
+}
+
+
+def _line_number(text: str, pos: int) -> int:
+    """Return 1-based line number for a character offset."""
+    return text[:pos].count("\n") + 1
+
+
+class DjangoAuthDetector:
+    """Detects Django auth decorators and mixin patterns in Python source files."""
+
+    name: str = "django_auth"
+    supported_languages: tuple[str, ...] = ("python",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # @login_required
+        for m in _LOGIN_REQUIRED_RE.finditer(text):
+            line = _line_number(text, m.start())
+            result.nodes.append(GraphNode(
+                id=f"auth:{ctx.file_path}:login_required:{line}",
+                kind=NodeKind.GUARD,
+                label="@login_required",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                annotations=["@login_required"],
+                properties={
+                    "auth_type": "django",
+                    "permissions": [],
+                    "auth_required": True,
+                },
+            ))
+
+        # @permission_required("perm")
+        for m in _PERMISSION_REQUIRED_RE.finditer(text):
+            line = _line_number(text, m.start())
+            permission = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"auth:{ctx.file_path}:permission_required:{line}",
+                kind=NodeKind.GUARD,
+                label=f"@permission_required({permission})",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                annotations=["@permission_required"],
+                properties={
+                    "auth_type": "django",
+                    "permissions": [permission],
+                    "auth_required": True,
+                },
+            ))
+
+        # @user_passes_test(fn)
+        for m in _USER_PASSES_TEST_RE.finditer(text):
+            line = _line_number(text, m.start())
+            test_func = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"auth:{ctx.file_path}:user_passes_test:{line}",
+                kind=NodeKind.GUARD,
+                label=f"@user_passes_test({test_func})",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                annotations=["@user_passes_test"],
+                properties={
+                    "auth_type": "django",
+                    "permissions": [],
+                    "test_function": test_func,
+                    "auth_required": True,
+                },
+            ))
+
+        # Class-based views with auth mixins
+        for m in _MIXIN_RE.finditer(text):
+            class_name = m.group(1)
+            bases_str = m.group(2)
+            bases = [b.strip() for b in bases_str.split(",")]
+
+            for base in bases:
+                if base in _AUTH_MIXINS:
+                    line = _line_number(text, m.start())
+                    result.nodes.append(GraphNode(
+                        id=f"auth:{ctx.file_path}:{base}:{line}",
+                        kind=NodeKind.GUARD,
+                        label=f"{class_name}({base})",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                        annotations=[f"mixin:{base}"],
+                        properties={
+                            "auth_type": "django",
+                            "permissions": [],
+                            "mixin": base,
+                            "class_name": class_name,
+                            "auth_required": True,
+                        },
+                    ))
+
+        return result