osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/config/gitlab_ci.py

@@ -0,0 +1,216 @@
+"""GitLab CI pipeline detector for .gitlab-ci.yml definitions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_GITLAB_CI_KEYWORDS = frozenset({
+    "stages",
+    "variables",
+    "default",
+    "workflow",
+    "include",
+    "image",
+    "services",
+    "before_script",
+    "after_script",
+    "cache",
+})
+
+_TOOL_KEYWORDS = (
+    "docker",
+    "helm",
+    "kubectl",
+    "terraform",
+    "maven",
+    "gradle",
+    "npm",
+    "pip",
+)
+
+
+def _is_gitlab_ci_file(ctx: DetectorContext) -> bool:
+    """Check whether the file is a GitLab CI configuration file."""
+    return ctx.file_path.endswith(".gitlab-ci.yml")
+
+
+def _detect_tools(scripts: list[Any]) -> list[str]:
+    """Scan script lines for known tool keywords."""
+    tools: list[str] = []
+    for line in scripts:
+        line_str = str(line)
+        for tool in _TOOL_KEYWORDS:
+            if tool in line_str and tool not in tools:
+                tools.append(tool)
+    return tools
+
+
+class GitLabCIDetector:
+    """Detects stages, jobs, dependencies, and tool usage from GitLab CI YAML files."""
+
+    name: str = "gitlab_ci"
+    supported_languages: tuple[str, ...] = ("yaml",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        if not _is_gitlab_ci_file(ctx):
+            return result
+
+        if not ctx.parsed_data:
+            return result
+
+        data = ctx.parsed_data.get("data")
+        if not isinstance(data, dict):
+            return result
+
+        fp = ctx.file_path
+        pipeline_id = f"gitlab:{fp}:pipeline"
+
+        # Pipeline MODULE node
+        result.nodes.append(GraphNode(
+            id=pipeline_id,
+            kind=NodeKind.MODULE,
+            label=f"pipeline:{fp}",
+            fqn=pipeline_id,
+            module=ctx.module_name,
+            location=SourceLocation(file_path=fp),
+            properties={"pipeline_file": fp},
+        ))
+
+        # Stages
+        stages = data.get("stages")
+        if isinstance(stages, list):
+            for stage_name in stages:
+                stage_str = str(stage_name)
+                result.nodes.append(GraphNode(
+                    id=f"gitlab:{fp}:stage:{stage_str}",
+                    kind=NodeKind.CONFIG_KEY,
+                    label=f"stage:{stage_str}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp),
+                    properties={"stage": stage_str},
+                ))
+
+        # Include directives
+        includes = data.get("include")
+        if includes is not None:
+            if isinstance(includes, str):
+                includes = [includes]
+            if isinstance(includes, list):
+                for inc in includes:
+                    if isinstance(inc, str):
+                        target = inc
+                    elif isinstance(inc, dict):
+                        target = inc.get("local") or inc.get("file") or inc.get("template") or str(inc)
+                    else:
+                        target = str(inc)
+                    result.edges.append(GraphEdge(
+                        source=pipeline_id,
+                        target=str(target),
+                        kind=EdgeKind.IMPORTS,
+                        label=f"includes {target}",
+                    ))
+
+        # Collect job names first for edge resolution
+        job_names: list[str] = []
+        for key in data:
+            key_str = str(key)
+            if key_str in _GITLAB_CI_KEYWORDS:
+                continue
+            val = data[key]
+            if isinstance(val, dict):
+                job_names.append(key_str)
+
+        job_ids: dict[str, str] = {}
+        for name in job_names:
+            job_ids[name] = f"gitlab:{fp}:job:{name}"
+
+        # Process each job
+        for job_name in job_names:
+            job_def = data[job_name]
+            job_id = job_ids[job_name]
+
+            props: dict[str, Any] = {}
+
+            # Stage property
+            stage_val = job_def.get("stage")
+            if stage_val is not None:
+                props["stage"] = str(stage_val)
+
+            # Image property
+            image_val = job_def.get("image")
+            if image_val is not None:
+                props["image"] = str(image_val)
+
+            # Script tool detection
+            scripts = job_def.get("script")
+            if isinstance(scripts, list):
+                tools = _detect_tools(scripts)
+                if tools:
+                    props["tools"] = tools
+
+            # Job METHOD node
+            result.nodes.append(GraphNode(
+                id=job_id,
+                kind=NodeKind.METHOD,
+                label=job_name,
+                fqn=job_id,
+                module=ctx.module_name,
+                location=SourceLocation(file_path=fp),
+                properties=props,
+            ))
+
+            # CONTAINS edge: pipeline -> job
+            result.edges.append(GraphEdge(
+                source=pipeline_id,
+                target=job_id,
+                kind=EdgeKind.CONTAINS,
+                label=f"pipeline contains job {job_name}",
+            ))
+
+            # needs: dependencies
+            needs = job_def.get("needs")
+            if isinstance(needs, str):
+                needs = [needs]
+            if isinstance(needs, list):
+                for dep in needs:
+                    # needs can be a string or a dict with "job" key
+                    if isinstance(dep, dict):
+                        dep_str = str(dep.get("job", ""))
+                    else:
+                        dep_str = str(dep)
+                    if dep_str and dep_str in job_ids:
+                        result.edges.append(GraphEdge(
+                            source=job_id,
+                            target=job_ids[dep_str],
+                            kind=EdgeKind.DEPENDS_ON,
+                            label=f"job {job_name} needs {dep_str}",
+                        ))
+
+            # extends: template inheritance
+            extends = job_def.get("extends")
+            if extends is not None:
+                if isinstance(extends, str):
+                    extends = [extends]
+                if isinstance(extends, list):
+                    for parent in extends:
+                        parent_str = str(parent)
+                        if parent_str in job_ids:
+                            result.edges.append(GraphEdge(
+                                source=job_id,
+                                target=job_ids[parent_str],
+                                kind=EdgeKind.EXTENDS,
+                                label=f"job {job_name} extends {parent_str}",
+                            ))
+
+        return result

osscodeiq/detectors/config/helm_chart.py

@@ -0,0 +1,187 @@
+"""Helm chart detector for Kubernetes Helm chart patterns.
+
+Detects Chart.yaml, values.yaml, and template references.
+"""
+
+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,
+)
+
+# Template value references: {{ .Values.key }}
+_VALUES_REF_RE = re.compile(
+    r"\{\{\s*\.Values\.([a-zA-Z0-9_.]+)\s*\}\}", re.MULTILINE
+)
+
+# Include helper references: {{ include "helper" }}
+_INCLUDE_RE = re.compile(
+    r'\{\{-?\s*include\s+["\']([^"\']+)["\']', re.MULTILINE
+)
+
+
+def _get_yaml_data(ctx: DetectorContext) -> dict[str, Any] | None:
+    """Extract YAML data from parsed_data."""
+    if not ctx.parsed_data:
+        return None
+
+    ptype = ctx.parsed_data.get("type")
+    if ptype == "yaml":
+        data = ctx.parsed_data.get("data")
+        if isinstance(data, dict):
+            return data
+    return None
+
+
+class HelmChartDetector:
+    """Detects Helm chart patterns in Chart.yaml, values.yaml, and templates."""
+
+    name: str = "helm_chart"
+    supported_languages: tuple[str, ...] = ("yaml",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        fp = ctx.file_path
+
+        if fp.endswith("Chart.yaml"):
+            self._detect_chart_yaml(ctx, result)
+        elif fp.endswith("values.yaml") and ("charts/" in fp or "helm/" in fp):
+            self._detect_values_yaml(ctx, result)
+        elif "/templates/" in fp and fp.endswith(".yaml"):
+            self._detect_template(ctx, result)
+        else:
+            return result
+
+        return result
+
+    def _detect_chart_yaml(
+        self, ctx: DetectorContext, result: DetectorResult
+    ) -> None:
+        """Parse Chart.yaml and emit MODULE + DEPENDS_ON edges."""
+        fp = ctx.file_path
+        data = _get_yaml_data(ctx)
+        if not data:
+            return
+
+        chart_name = data.get("name", "unknown")
+        chart_version = data.get("version", "0.0.0")
+
+        chart_node_id = f"helm:{fp}:chart:{chart_name}"
+        result.nodes.append(GraphNode(
+            id=chart_node_id,
+            kind=NodeKind.MODULE,
+            label=f"helm:{chart_name}",
+            fqn=f"helm:{chart_name}:{chart_version}",
+            module=ctx.module_name,
+            location=SourceLocation(file_path=fp),
+            properties={
+                "chart_name": str(chart_name),
+                "chart_version": str(chart_version),
+                "type": "helm_chart",
+            },
+        ))
+
+        # Process dependencies
+        dependencies = data.get("dependencies")
+        if isinstance(dependencies, list):
+            for dep in dependencies:
+                if not isinstance(dep, dict):
+                    continue
+                dep_name = dep.get("name", "")
+                dep_version = dep.get("version", "")
+                dep_repo = dep.get("repository", "")
+                if not dep_name:
+                    continue
+
+                dep_node_id = f"helm:{fp}:dep:{dep_name}"
+                result.nodes.append(GraphNode(
+                    id=dep_node_id,
+                    kind=NodeKind.MODULE,
+                    label=f"helm-dep:{dep_name}",
+                    fqn=f"helm:{dep_name}:{dep_version}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp),
+                    properties={
+                        "chart_name": str(dep_name),
+                        "chart_version": str(dep_version),
+                        "repository": str(dep_repo),
+                        "type": "helm_dependency",
+                    },
+                ))
+
+                result.edges.append(GraphEdge(
+                    source=chart_node_id,
+                    target=dep_node_id,
+                    kind=EdgeKind.DEPENDS_ON,
+                    label=f"{chart_name} depends on {dep_name}",
+                    properties={"version": str(dep_version)},
+                ))
+
+    def _detect_values_yaml(
+        self, ctx: DetectorContext, result: DetectorResult
+    ) -> None:
+        """Parse values.yaml and emit CONFIG_KEY nodes for top-level keys."""
+        fp = ctx.file_path
+        data = _get_yaml_data(ctx)
+        if not data:
+            return
+
+        for key in sorted(data.keys()):
+            result.nodes.append(GraphNode(
+                id=f"helm:{fp}:value:{key}",
+                kind=NodeKind.CONFIG_KEY,
+                label=f"helm-value:{key}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=fp),
+                properties={"helm_value": True, "key": str(key)},
+            ))
+
+    def _detect_template(
+        self, ctx: DetectorContext, result: DetectorResult
+    ) -> None:
+        """Parse template files for .Values references and include directives."""
+        fp = ctx.file_path
+        text = decode_text(ctx)
+        lines = text.split("\n")
+        file_node_id = f"helm:{fp}:template"
+
+        seen_values: set[str] = set()
+        seen_includes: set[str] = set()
+
+        for i, line in enumerate(lines):
+            lineno = i + 1
+
+            # Detect {{ .Values.key }}
+            for m in _VALUES_REF_RE.finditer(line):
+                key = m.group(1)
+                if key not in seen_values:
+                    seen_values.add(key)
+                    result.edges.append(GraphEdge(
+                        source=file_node_id,
+                        target=f"helm:values:{key}",
+                        kind=EdgeKind.READS_CONFIG,
+                        label=f"reads .Values.{key}",
+                        properties={"key": key, "line": lineno},
+                    ))
+
+            # Detect {{ include "helper" }}
+            for m in _INCLUDE_RE.finditer(line):
+                helper = m.group(1)
+                if helper not in seen_includes:
+                    seen_includes.add(helper)
+                    result.edges.append(GraphEdge(
+                        source=file_node_id,
+                        target=f"helm:helper:{helper}",
+                        kind=EdgeKind.IMPORTS,
+                        label=f"includes {helper}",
+                        properties={"helper": helper, "line": lineno},
+                    ))

osscodeiq/detectors/config/ini_structure.py

@@ -0,0 +1,101 @@
+"""Generic INI/CFG/CONF structure detector for all .ini/.cfg/.conf files."""
+
+from __future__ import annotations
+
+import configparser
+
+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 IniStructureDetector:
+    """Detects INI file structures: sections, keys, and file identity."""
+
+    name: str = "ini_structure"
+    supported_languages: tuple[str, ...] = ("ini",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        file_id = f"ini:{ctx.file_path}"
+
+        # Create CONFIG_FILE node for the file itself
+        result.nodes.append(GraphNode(
+            id=file_id,
+            kind=NodeKind.CONFIG_FILE,
+            label=ctx.file_path,
+            fqn=ctx.file_path,
+            module=ctx.module_name,
+            location=SourceLocation(
+                file_path=ctx.file_path,
+                line_start=1,
+            ),
+            properties={"format": "ini"},
+        ))
+
+        # Parse INI from raw content
+        try:
+            text = decode_text(ctx)
+            parser = configparser.ConfigParser()
+            parser.read_string(text)
+        except Exception:
+            return result
+
+        for section in parser.sections():
+            section_id = f"ini:{ctx.file_path}:{section}"
+
+            # Create CONFIG_KEY node for the section
+            result.nodes.append(GraphNode(
+                id=section_id,
+                kind=NodeKind.CONFIG_KEY,
+                label=section,
+                fqn=f"{ctx.file_path}:{section}",
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                ),
+                properties={"section": True},
+            ))
+
+            result.edges.append(GraphEdge(
+                source=file_id,
+                target=section_id,
+                kind=EdgeKind.CONTAINS,
+                label=f"{ctx.file_path} contains [{section}]",
+            ))
+
+            # Create CONFIG_KEY nodes for keys within the section
+            for key in parser.options(section):
+                # Skip keys inherited from DEFAULT
+                if section != "DEFAULT" and key in parser.defaults() and parser.get(section, key) == parser.defaults()[key]:
+                    continue
+
+                key_id = f"ini:{ctx.file_path}:{section}:{key}"
+
+                result.nodes.append(GraphNode(
+                    id=key_id,
+                    kind=NodeKind.CONFIG_KEY,
+                    label=key,
+                    fqn=f"{ctx.file_path}:{section}:{key}",
+                    module=ctx.module_name,
+                    location=SourceLocation(
+                        file_path=ctx.file_path,
+                    ),
+                    properties={"section": section},
+                ))
+
+                result.edges.append(GraphEdge(
+                    source=section_id,
+                    target=key_id,
+                    kind=EdgeKind.CONTAINS,
+                    label=f"[{section}] contains {key}",
+                ))
+
+        return result

osscodeiq/detectors/config/json_structure.py

@@ -0,0 +1,72 @@
+"""Generic JSON structure detector for all .json files."""
+
+from __future__ import annotations
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+
+class JsonStructureDetector:
+    """Detects JSON file structures: top-level keys and file identity."""
+
+    name: str = "json_structure"
+    supported_languages: tuple[str, ...] = ("json",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        file_id = f"json:{ctx.file_path}"
+
+        # Create CONFIG_FILE node for the file itself
+        result.nodes.append(GraphNode(
+            id=file_id,
+            kind=NodeKind.CONFIG_FILE,
+            label=ctx.file_path,
+            fqn=ctx.file_path,
+            module=ctx.module_name,
+            location=SourceLocation(
+                file_path=ctx.file_path,
+                line_start=1,
+            ),
+            properties={"format": "json"},
+        ))
+
+        # Extract data from parsed_data
+        data = None
+        if isinstance(ctx.parsed_data, dict):
+            data = ctx.parsed_data.get("data")
+
+        if data is None:
+            return result
+
+        # Only extract top-level keys from dicts
+        if isinstance(data, dict):
+            for key in data:
+                key_str = str(key)
+                key_id = f"json:{ctx.file_path}:{key_str}"
+
+                result.nodes.append(GraphNode(
+                    id=key_id,
+                    kind=NodeKind.CONFIG_KEY,
+                    label=key_str,
+                    fqn=f"{ctx.file_path}:{key_str}",
+                    module=ctx.module_name,
+                    location=SourceLocation(
+                        file_path=ctx.file_path,
+                    ),
+                ))
+
+                result.edges.append(GraphEdge(
+                    source=file_id,
+                    target=key_id,
+                    kind=EdgeKind.CONTAINS,
+                    label=f"{ctx.file_path} contains {key_str}",
+                ))
+
+        return result