osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/go/go_structures.py

@@ -0,0 +1,162 @@
+"""Regex-based Go structures detector for Go 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, find_line_number
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_STRUCT_RE = re.compile(r'type\s+(\w+)\s+struct\s*\{')
+_INTERFACE_RE = re.compile(r'type\s+(\w+)\s+interface\s*\{')
+_METHOD_RE = re.compile(r'func\s+\(\s*\w+\s+\*?(\w+)\s*\)\s+(\w+)\s*\(')
+_FUNC_RE = re.compile(r'^func\s+(\w+)\s*\(', re.MULTILINE)
+_PACKAGE_RE = re.compile(r'^package\s+(\w+)', re.MULTILINE)
+_IMPORT_SINGLE_RE = re.compile(r'^import\s+"([^"]+)"', re.MULTILINE)
+_IMPORT_BLOCK_RE = re.compile(r'import\s*\((.*?)\)', re.DOTALL)
+_IMPORT_PATH_RE = re.compile(r'"([^"]+)"')
+
+
+
+class GoStructuresDetector:
+    """Detects Go structs, interfaces, methods, functions, and packages."""
+
+    name: str = "go_structures"
+    supported_languages: tuple[str, ...] = ("go",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Package declaration (one per file)
+        pkg_match = _PACKAGE_RE.search(text)
+        pkg_name = pkg_match.group(1) if pkg_match else None
+        if pkg_name:
+            pkg_node_id = f"{ctx.file_path}:package:{pkg_name}"
+            result.nodes.append(GraphNode(
+                id=pkg_node_id,
+                kind=NodeKind.MODULE,
+                label=pkg_name,
+                fqn=pkg_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, pkg_match.start()),
+                ),
+                properties={"package": pkg_name},
+            ))
+
+        # Imports
+        file_node_id = ctx.file_path
+        for m in _IMPORT_SINGLE_RE.finditer(text):
+            import_path = m.group(1)
+            result.edges.append(GraphEdge(
+                source=file_node_id,
+                target=import_path,
+                kind=EdgeKind.IMPORTS,
+                label=f"{ctx.file_path} imports {import_path}",
+            ))
+
+        for block_m in _IMPORT_BLOCK_RE.finditer(text):
+            block_text = block_m.group(1)
+            for path_m in _IMPORT_PATH_RE.finditer(block_text):
+                import_path = path_m.group(1)
+                result.edges.append(GraphEdge(
+                    source=file_node_id,
+                    target=import_path,
+                    kind=EdgeKind.IMPORTS,
+                    label=f"{ctx.file_path} imports {import_path}",
+                ))
+
+        # Struct declarations
+        for m in _STRUCT_RE.finditer(text):
+            struct_name = m.group(1)
+            exported = struct_name[0].isupper()
+            node_id = f"{ctx.file_path}:{struct_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.CLASS,
+                label=struct_name,
+                fqn=f"{pkg_name}.{struct_name}" if pkg_name else struct_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties={"exported": exported, "type": "struct"},
+            ))
+
+        # Interface declarations
+        for m in _INTERFACE_RE.finditer(text):
+            iface_name = m.group(1)
+            exported = iface_name[0].isupper()
+            node_id = f"{ctx.file_path}:{iface_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.INTERFACE,
+                label=iface_name,
+                fqn=f"{pkg_name}.{iface_name}" if pkg_name else iface_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties={"exported": exported},
+            ))
+
+        # Method declarations (receiver methods)
+        for m in _METHOD_RE.finditer(text):
+            receiver_type = m.group(1)
+            method_name = m.group(2)
+            exported = method_name[0].isupper()
+            node_id = f"{ctx.file_path}:{receiver_type}:{method_name}"
+            type_node_id = f"{ctx.file_path}:{receiver_type}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.METHOD,
+                label=f"{receiver_type}.{method_name}",
+                fqn=f"{pkg_name}.{receiver_type}.{method_name}" if pkg_name else f"{receiver_type}.{method_name}",
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties={"exported": exported, "receiver_type": receiver_type},
+            ))
+            result.edges.append(GraphEdge(
+                source=type_node_id,
+                target=node_id,
+                kind=EdgeKind.DEFINES,
+                label=f"{receiver_type} defines {method_name}",
+            ))
+
+        # Package-level function declarations (exclude methods already matched)
+        method_positions = {m.start() for m in _METHOD_RE.finditer(text)}
+        for m in _FUNC_RE.finditer(text):
+            if m.start() in method_positions:
+                continue
+            func_name = m.group(1)
+            exported = func_name[0].isupper()
+            node_id = f"{ctx.file_path}:{func_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.METHOD,
+                label=func_name,
+                fqn=f"{pkg_name}.{func_name}" if pkg_name else func_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties={"exported": exported, "type": "function"},
+            ))
+
+        return result

osscodeiq/detectors/go/go_web.py

@@ -0,0 +1,157 @@
+"""Go web framework detector for Gin, Echo, Chi, gorilla/mux, and net/http."""
+
+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 GraphEdge, GraphNode, NodeKind, SourceLocation
+
+# --- Route patterns ---
+# Gin/Echo (uppercase methods): r.GET("/path", handler)
+_UPPER_ROUTE_RE = re.compile(
+    r"\.(?P<method>GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s*\(\s*\"(?P<path>[^\"]*)\"",
+    re.MULTILINE,
+)
+# Chi (lowercase methods): r.Get("/path", handler)
+_LOWER_ROUTE_RE = re.compile(
+    r"\.(?P<method>Get|Post|Put|Delete|Patch|Head|Options)\s*\(\s*\"(?P<path>[^\"]*)\"",
+    re.MULTILINE,
+)
+# gorilla/mux: r.HandleFunc("/path", handler).Methods("GET")
+_HANDLEFUNC_RE = re.compile(
+    r"\.HandleFunc\s*\(\s*\"(?P<path>[^\"]*)\".*?\.Methods\s*\(\s*\"(?P<method>[A-Z]+)\"",
+    re.DOTALL,
+)
+# gorilla/mux HandleFunc without .Methods() (default any)
+_HANDLEFUNC_NO_METHOD_RE = re.compile(
+    r"\.HandleFunc\s*\(\s*\"(?P<path>[^\"]*)\"",
+    re.MULTILINE,
+)
+# net/http: http.HandleFunc("/path", handler) / http.Handle("/path", handler)
+_HTTP_HANDLE_RE = re.compile(
+    r"http\.(?:HandleFunc|Handle)\s*\(\s*\"(?P<path>[^\"]*)\"",
+    re.MULTILINE,
+)
+
+# --- Framework detection ---
+_GIN_RE = re.compile(r"gin\.(?:Default|New)\s*\(")
+_ECHO_RE = re.compile(r"echo\.New\s*\(")
+_CHI_RE = re.compile(r"chi\.NewRouter\s*\(")
+_MUX_RE = re.compile(r"mux\.NewRouter\s*\(")
+
+# --- Middleware ---
+_USE_RE = re.compile(r"\.Use\s*\(\s*(\w+)")
+
+
+def _detect_framework(text: str) -> str:
+    """Determine which framework is in use based on constructor patterns."""
+    if _GIN_RE.search(text):
+        return "gin"
+    if _ECHO_RE.search(text):
+        return "echo"
+    if _CHI_RE.search(text):
+        return "chi"
+    if _MUX_RE.search(text):
+        return "mux"
+    return "net_http"
+
+
+class GoWebDetector:
+    """Detects Go web framework route definitions across Gin, Echo, Chi, mux, and net/http."""
+
+    name: str = "go_web"
+    supported_languages: tuple[str, ...] = ("go",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        framework = _detect_framework(text)
+
+        # Collect (method, path, line, matched_framework) tuples
+        routes: list[tuple[str, str, int, str]] = []
+
+        # Gin/Echo uppercase routes
+        for m in _UPPER_ROUTE_RE.finditer(text):
+            method = m.group("method")
+            path = m.group("path")
+            line = find_line_number(text, m.start())
+            routes.append((method, path, line, framework))
+
+        # Chi lowercase routes
+        for m in _LOWER_ROUTE_RE.finditer(text):
+            method = m.group("method").upper()
+            path = m.group("path")
+            line = find_line_number(text, m.start())
+            routes.append((method, path, line, "chi"))
+
+        # gorilla/mux HandleFunc with .Methods()
+        handlefunc_with_method_positions: set[int] = set()
+        for m in _HANDLEFUNC_RE.finditer(text):
+            method = m.group("method")
+            path = m.group("path")
+            line = find_line_number(text, m.start())
+            routes.append((method, path, line, "mux"))
+            handlefunc_with_method_positions.add(m.start())
+
+        # gorilla/mux HandleFunc without .Methods() — only if mux detected
+        # and not already captured with methods
+        if framework == "mux":
+            for m in _HANDLEFUNC_NO_METHOD_RE.finditer(text):
+                if m.start() in handlefunc_with_method_positions:
+                    continue
+                # Check if this same position was already matched by _HANDLEFUNC_RE
+                already_matched = False
+                for pos in handlefunc_with_method_positions:
+                    if pos == m.start():
+                        already_matched = True
+                        break
+                if not already_matched:
+                    path = m.group("path")
+                    line = find_line_number(text, m.start())
+                    routes.append(("ANY", path, line, "mux"))
+
+        # net/http Handle/HandleFunc
+        for m in _HTTP_HANDLE_RE.finditer(text):
+            path = m.group("path")
+            line = find_line_number(text, m.start())
+            routes.append(("ANY", path, line, "net_http"))
+
+        # Emit ENDPOINT nodes
+        for method, path, line, fw in routes:
+            node_id = f"go_web:{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={
+                    "framework": fw,
+                    "http_method": method,
+                    "path": path,
+                },
+            ))
+
+        # Middleware nodes
+        for m in _USE_RE.finditer(text):
+            mw_name = m.group(1)
+            line = find_line_number(text, m.start())
+            node_id = f"go_web:{ctx.file_path}:middleware:{mw_name}:{line}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.MIDDLEWARE,
+                label=mw_name,
+                fqn=f"{ctx.file_path}::middleware:{mw_name}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                properties={
+                    "framework": framework,
+                    "middleware": mw_name,
+                },
+            ))
+
+        return result

osscodeiq/detectors/iac/bicep.py

@@ -0,0 +1,135 @@
+"""Bicep IaC detector for Azure infrastructure resource definitions."""
+
+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,
+)
+
+# resource <symbolName> '<type>@<apiVersion>'
+_RESOURCE_RE = re.compile(r"resource\s+(\w+)\s+'([^']+)'")
+
+# param <name> <type>
+_PARAM_RE = re.compile(r"param\s+(\w+)\s+(\w+)")
+
+# module <name> '<path>'
+_MODULE_RE = re.compile(r"module\s+(\w+)\s+'([^']+)'")
+
+
+def _parse_resource_type(type_str: str) -> dict[str, str]:
+    """Parse 'Microsoft.DocumentDB/databaseAccounts@2023-04-15' into parts."""
+    props: dict[str, str] = {}
+    if "@" in type_str:
+        azure_type, api_version = type_str.rsplit("@", 1)
+        props["azure_type"] = azure_type
+        props["api_version"] = api_version
+    else:
+        props["azure_type"] = type_str
+    return props
+
+
+class BicepDetector:
+    """Detects Azure infrastructure resources from Bicep files."""
+
+    name: str = "bicep"
+    supported_languages: tuple[str, ...] = ("bicep",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        # Detect resource declarations
+        for i, line in enumerate(lines):
+            m = _RESOURCE_RE.search(line)
+            if not m:
+                continue
+
+            resource_name = m.group(1)
+            type_str = m.group(2)
+            props = _parse_resource_type(type_str)
+            azure_type = props.get("azure_type", "")
+
+            # Use AZURE_RESOURCE for Microsoft.* types, INFRA_RESOURCE otherwise
+            if azure_type.startswith("Microsoft."):
+                kind = NodeKind.AZURE_RESOURCE
+            else:
+                kind = NodeKind.INFRA_RESOURCE
+
+            node_id = f"{ctx.file_path}:resource:{resource_name}"
+            label = f"{resource_name} ({azure_type})"
+
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=kind,
+                label=label,
+                fqn=azure_type,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=i + 1,
+                ),
+                properties=props,
+            ))
+
+        # Detect param declarations
+        for i, line in enumerate(lines):
+            m = _PARAM_RE.search(line)
+            if not m:
+                continue
+
+            param_name = m.group(1)
+            param_type = m.group(2)
+
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:param:{param_name}",
+                kind=NodeKind.CONFIG_KEY,
+                label=f"param {param_name}: {param_type}",
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=i + 1,
+                ),
+                properties={"param_type": param_type},
+            ))
+
+        # Detect module references
+        for i, line in enumerate(lines):
+            m = _MODULE_RE.search(line)
+            if not m:
+                continue
+
+            module_name = m.group(1)
+            module_path = m.group(2)
+
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:module:{module_name}",
+                kind=NodeKind.INFRA_RESOURCE,
+                label=f"module {module_name} ({module_path})",
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=i + 1,
+                ),
+                properties={"module_path": module_path},
+            ))
+
+            # Edge: current file depends on the referenced module
+            result.edges.append(GraphEdge(
+                source=ctx.file_path,
+                target=module_path,
+                kind=EdgeKind.DEPENDS_ON,
+                label=f"{ctx.file_path} depends on module {module_path}",
+                properties={"module_name": module_name},
+            ))
+
+        return result

osscodeiq/detectors/iac/dockerfile.py

@@ -0,0 +1,182 @@
+"""Dockerfile detector for container infrastructure definitions."""
+
+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,
+)
+
+_FROM_RE = re.compile(r'^FROM\s+(\S+)(?:\s+AS\s+(\w+))?', re.MULTILINE | re.IGNORECASE)
+_EXPOSE_RE = re.compile(r'^EXPOSE\s+(\d+)', re.MULTILINE)
+_ENV_RE = re.compile(r'^ENV\s+(\w+)[=\s]', re.MULTILINE)
+_LABEL_RE = re.compile(r'^LABEL\s+(\S+)=', re.MULTILINE)
+_COPY_FROM_RE = re.compile(r'COPY\s+--from=(\w+)', re.MULTILINE | re.IGNORECASE)
+_ARG_RE = re.compile(r'^ARG\s+(\w+)', re.MULTILINE)
+
+
+
+class DockerfileDetector:
+    """Detects infrastructure resources from Dockerfile definitions."""
+
+    name: str = "dockerfile"
+    supported_languages: tuple[str, ...] = ("dockerfile",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        stages: dict[str, str] = {}  # stage alias -> base image
+        stage_node_ids: dict[str, str] = {}  # stage alias -> node id
+        # Ordered list of (start_offset, node_id) for determining current stage
+        from_offsets: list[tuple[int, str]] = []
+        stage_order = 0
+
+        # Detect FROM instructions (base image dependencies)
+        for m in _FROM_RE.finditer(text):
+            image = m.group(1)
+            alias = m.group(2)
+            line = find_line_number(text, m.start())
+
+            # Track stage aliases for multi-stage build references
+            if alias:
+                stages[alias] = image
+
+            # Parse image name and tag
+            props: dict[str, str | int] = {"image": image}
+            if ":" in image and not image.startswith("$"):
+                img_name, tag = image.rsplit(":", 1)
+                props["image_name"] = img_name
+                props["tag"] = tag
+            else:
+                props["image_name"] = image
+
+            if alias:
+                props["stage_alias"] = alias
+                props["build_stage"] = alias
+
+            props["stage_order"] = stage_order
+            stage_order += 1
+
+            node_id = f"docker:{ctx.file_path}:from:{image}"
+            label = f"FROM {image}" + (f" AS {alias}" if alias else "")
+
+            if alias:
+                stage_node_ids[alias] = node_id
+            from_offsets.append((m.start(), node_id))
+
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.INFRA_RESOURCE,
+                label=label,
+                fqn=image,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=line,
+                ),
+                properties=props,
+            ))
+
+            # Edge: this Dockerfile depends on the base image
+            result.edges.append(GraphEdge(
+                source=ctx.file_path,
+                target=image,
+                kind=EdgeKind.DEPENDS_ON,
+                label=f"{ctx.file_path} depends on image {image}",
+            ))
+
+        # Detect COPY --from instructions (multi-stage build dependencies)
+        for m in _COPY_FROM_RE.finditer(text):
+            source_stage = m.group(1)
+            if source_stage in stage_node_ids:
+                # Find the current stage (most recent FROM before this COPY)
+                current_node_id = None
+                for offset, nid in reversed(from_offsets):
+                    if offset < m.start():
+                        current_node_id = nid
+                        break
+                if current_node_id and current_node_id != stage_node_ids[source_stage]:
+                    result.edges.append(GraphEdge(
+                        source=current_node_id,
+                        target=stage_node_ids[source_stage],
+                        kind=EdgeKind.DEPENDS_ON,
+                        label=f"COPY --from={source_stage}",
+                    ))
+
+        # Detect EXPOSE instructions (exposed ports)
+        for m in _EXPOSE_RE.finditer(text):
+            port = m.group(1)
+            line = find_line_number(text, m.start())
+
+            result.nodes.append(GraphNode(
+                id=f"docker:{ctx.file_path}:expose:{port}",
+                kind=NodeKind.ENDPOINT,
+                label=f"EXPOSE {port}",
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=line,
+                ),
+                properties={"port": port, "protocol": "tcp"},
+            ))
+
+        # Detect ENV instructions (configuration definitions)
+        for m in _ENV_RE.finditer(text):
+            key = m.group(1)
+            line = find_line_number(text, m.start())
+
+            result.nodes.append(GraphNode(
+                id=f"docker:{ctx.file_path}:env:{key}",
+                kind=NodeKind.CONFIG_DEFINITION,
+                label=f"ENV {key}",
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=line,
+                ),
+                properties={"env_key": key},
+            ))
+
+        # Detect LABEL instructions
+        for m in _LABEL_RE.finditer(text):
+            label_key = m.group(1)
+            line = find_line_number(text, m.start())
+
+            result.nodes.append(GraphNode(
+                id=f"docker:{ctx.file_path}:label:{label_key}",
+                kind=NodeKind.CONFIG_DEFINITION,
+                label=f"LABEL {label_key}",
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=line,
+                ),
+                properties={"label_key": label_key},
+            ))
+
+        # Detect ARG instructions (build arguments)
+        for m in _ARG_RE.finditer(text):
+            arg_name = m.group(1)
+            line = find_line_number(text, m.start())
+
+            result.nodes.append(GraphNode(
+                id=f"docker:{ctx.file_path}:arg:{arg_name}",
+                kind=NodeKind.CONFIG_DEFINITION,
+                label=f"ARG {arg_name}",
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=line,
+                ),
+                properties={"arg_name": arg_name},
+            ))
+
+        return result