osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/config/cloudformation.py

@@ -0,0 +1,183 @@
+"""AWS CloudFormation template detector.
+
+Detects CloudFormation resources, parameters, outputs, and cross-resource references.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+# Pattern for !GetAtt in text-based detection
+_GETATT_RE = re.compile(r"!GetAtt\s+(\w+)\.", re.MULTILINE)
+_REF_RE = re.compile(r"!Ref\s+(\w+)", re.MULTILINE)
+
+
+def _is_cfn_template(data: dict[str, Any]) -> bool:
+    """Check whether parsed data looks like a CloudFormation template."""
+    if "AWSTemplateFormatVersion" in data:
+        return True
+    resources = data.get("Resources")
+    if isinstance(resources, dict):
+        for _key, val in resources.items():
+            if isinstance(val, dict):
+                rtype = val.get("Type", "")
+                if isinstance(rtype, str) and rtype.startswith("AWS::"):
+                    return True
+    return False
+
+
+def _get_data(ctx: DetectorContext) -> dict[str, Any] | None:
+    """Extract data from parsed_data for YAML or JSON types."""
+    if not ctx.parsed_data:
+        return None
+
+    ptype = ctx.parsed_data.get("type")
+    if ptype in ("yaml", "json"):
+        data = ctx.parsed_data.get("data")
+        if isinstance(data, dict) and _is_cfn_template(data):
+            return data
+    return None
+
+
+def _collect_refs(value: Any, refs: set[str]) -> None:
+    """Recursively collect Ref and Fn::GetAtt references from a value tree."""
+    if isinstance(value, dict):
+        if "Ref" in value:
+            ref = value["Ref"]
+            if isinstance(ref, str):
+                refs.add(ref)
+        if "Fn::GetAtt" in value:
+            getatt = value["Fn::GetAtt"]
+            if isinstance(getatt, list) and len(getatt) >= 1:
+                refs.add(str(getatt[0]))
+            elif isinstance(getatt, str) and "." in getatt:
+                refs.add(getatt.split(".")[0])
+        for v in value.values():
+            _collect_refs(v, refs)
+    elif isinstance(value, list):
+        for item in value:
+            _collect_refs(item, refs)
+
+
+class CloudFormationDetector:
+    """Detects AWS CloudFormation resources, parameters, outputs, and dependencies."""
+
+    name: str = "cloudformation"
+    supported_languages: tuple[str, ...] = ("yaml", "json")
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        fp = ctx.file_path
+
+        data = _get_data(ctx)
+        if not data:
+            return result
+
+        resource_ids: set[str] = set()
+
+        # Process Resources
+        resources = data.get("Resources")
+        if isinstance(resources, dict):
+            for logical_id, resource in sorted(resources.items()):
+                if not isinstance(resource, dict):
+                    continue
+
+                resource_type = resource.get("Type", "unknown")
+                node_id = f"cfn:{fp}:resource:{logical_id}"
+                resource_ids.add(logical_id)
+
+                result.nodes.append(GraphNode(
+                    id=node_id,
+                    kind=NodeKind.INFRA_RESOURCE,
+                    label=f"{logical_id} ({resource_type})",
+                    fqn=f"cfn:{logical_id}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp),
+                    properties={
+                        "logical_id": str(logical_id),
+                        "resource_type": str(resource_type),
+                    },
+                ))
+
+                # Collect Ref and Fn::GetAtt references within this resource
+                refs: set[str] = set()
+                _collect_refs(resource, refs)
+                # Remove self-reference
+                refs.discard(logical_id)
+
+                for ref in sorted(refs):
+                    result.edges.append(GraphEdge(
+                        source=node_id,
+                        target=f"cfn:{fp}:resource:{ref}",
+                        kind=EdgeKind.DEPENDS_ON,
+                        label=f"{logical_id} -> {ref}",
+                        properties={"ref_type": "Ref/GetAtt"},
+                    ))
+
+        # Process Parameters
+        parameters = data.get("Parameters")
+        if isinstance(parameters, dict):
+            for param_name, param_def in sorted(parameters.items()):
+                if not isinstance(param_def, dict):
+                    continue
+
+                param_type = param_def.get("Type", "String")
+                default = param_def.get("Default")
+                description = param_def.get("Description", "")
+
+                props: dict[str, Any] = {
+                    "param_type": str(param_type),
+                    "cfn_type": "parameter",
+                }
+                if default is not None:
+                    props["default"] = str(default)
+                if description:
+                    props["description"] = str(description)
+
+                result.nodes.append(GraphNode(
+                    id=f"cfn:{fp}:parameter:{param_name}",
+                    kind=NodeKind.CONFIG_DEFINITION,
+                    label=f"param:{param_name}",
+                    fqn=f"cfn:param:{param_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp),
+                    properties=props,
+                ))
+
+        # Process Outputs
+        outputs = data.get("Outputs")
+        if isinstance(outputs, dict):
+            for output_name, output_def in sorted(outputs.items()):
+                if not isinstance(output_def, dict):
+                    continue
+
+                description = output_def.get("Description", "")
+                props_out: dict[str, Any] = {"cfn_type": "output"}
+                if description:
+                    props_out["description"] = str(description)
+
+                export = output_def.get("Export")
+                if isinstance(export, dict) and "Name" in export:
+                    props_out["export_name"] = str(export["Name"])
+
+                result.nodes.append(GraphNode(
+                    id=f"cfn:{fp}:output:{output_name}",
+                    kind=NodeKind.CONFIG_DEFINITION,
+                    label=f"output:{output_name}",
+                    fqn=f"cfn:output:{output_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp),
+                    properties=props_out,
+                ))
+
+        return result

osscodeiq/detectors/config/docker_compose.py

@@ -0,0 +1,179 @@
+"""Docker Compose detector for container orchestration definitions."""
+
+from __future__ import annotations
+
+import os
+import re
+from typing import Any
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_COMPOSE_FILENAME_RE = re.compile(
+    r"^(docker-compose|compose).*\.(yml|yaml)$", re.IGNORECASE
+)
+
+
+def _is_compose_file(ctx: DetectorContext) -> bool:
+    """Check whether the file is a Docker Compose file."""
+    basename = os.path.basename(ctx.file_path)
+    if _COMPOSE_FILENAME_RE.match(basename):
+        return True
+    # Fallback: check parsed data for compose-like structure
+    if ctx.parsed_data and ctx.parsed_data.get("type") == "yaml":
+        data = ctx.parsed_data.get("data")
+        if isinstance(data, dict) and "services" in data:
+            return True
+    return False
+
+
+class DockerComposeDetector:
+    """Detects services, ports, volumes, networks, and dependencies from Docker Compose files."""
+
+    name: str = "docker_compose"
+    supported_languages: tuple[str, ...] = ("yaml",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        if not _is_compose_file(ctx):
+            return result
+
+        if not ctx.parsed_data:
+            return result
+
+        data = ctx.parsed_data.get("data")
+        if not isinstance(data, dict):
+            return result
+
+        services = data.get("services")
+        if not isinstance(services, dict):
+            return result
+
+        fp = ctx.file_path
+
+        # Build a set of known service IDs for edge resolution
+        service_ids: dict[str, str] = {}
+        for svc_name in services:
+            service_ids[svc_name] = f"compose:{fp}:service:{svc_name}"
+
+        for svc_name, svc_def in services.items():
+            if not isinstance(svc_def, dict):
+                continue
+
+            svc_id = service_ids[svc_name]
+
+            # Properties for the service node
+            props: dict[str, Any] = {}
+            if "image" in svc_def:
+                props["image"] = str(svc_def["image"])
+            build = svc_def.get("build")
+            if isinstance(build, str):
+                props["build_context"] = build
+            elif isinstance(build, dict) and "context" in build:
+                props["build_context"] = str(build["context"])
+
+            # INFRA_RESOURCE node for the service
+            result.nodes.append(GraphNode(
+                id=svc_id,
+                kind=NodeKind.INFRA_RESOURCE,
+                label=svc_name,
+                fqn=f"compose:{svc_name}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=fp),
+                properties=props,
+            ))
+
+            # Ports
+            ports = svc_def.get("ports")
+            if isinstance(ports, list):
+                for port_entry in ports:
+                    port_str = str(port_entry)
+                    result.nodes.append(GraphNode(
+                        id=f"compose:{fp}:service:{svc_name}:port:{port_str}",
+                        kind=NodeKind.CONFIG_KEY,
+                        label=f"{svc_name} port {port_str}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=fp),
+                        properties={"port": port_str},
+                    ))
+
+            # depends_on
+            depends_on = svc_def.get("depends_on")
+            if isinstance(depends_on, list):
+                for dep in depends_on:
+                    dep_str = str(dep)
+                    if dep_str in service_ids:
+                        result.edges.append(GraphEdge(
+                            source=svc_id,
+                            target=service_ids[dep_str],
+                            kind=EdgeKind.DEPENDS_ON,
+                            label=f"{svc_name} depends on {dep_str}",
+                        ))
+            elif isinstance(depends_on, dict):
+                for dep_str in depends_on:
+                    if dep_str in service_ids:
+                        result.edges.append(GraphEdge(
+                            source=svc_id,
+                            target=service_ids[dep_str],
+                            kind=EdgeKind.DEPENDS_ON,
+                            label=f"{svc_name} depends on {dep_str}",
+                        ))
+
+            # links
+            links = svc_def.get("links")
+            if isinstance(links, list):
+                for link in links:
+                    link_name = str(link).split(":")[0]
+                    if link_name in service_ids:
+                        result.edges.append(GraphEdge(
+                            source=svc_id,
+                            target=service_ids[link_name],
+                            kind=EdgeKind.CONNECTS_TO,
+                            label=f"{svc_name} links to {link_name}",
+                        ))
+
+            # Volumes
+            volumes = svc_def.get("volumes")
+            if isinstance(volumes, list):
+                for vol_entry in volumes:
+                    vol_str = str(vol_entry) if not isinstance(vol_entry, dict) else vol_entry.get("source", str(vol_entry))
+                    result.nodes.append(GraphNode(
+                        id=f"compose:{fp}:service:{svc_name}:volume:{vol_str}",
+                        kind=NodeKind.CONFIG_KEY,
+                        label=f"{svc_name} volume {vol_str}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=fp),
+                        properties={"volume": vol_str},
+                    ))
+
+            # Networks
+            networks = svc_def.get("networks")
+            if isinstance(networks, list):
+                for net in networks:
+                    result.nodes.append(GraphNode(
+                        id=f"compose:{fp}:service:{svc_name}:network:{net}",
+                        kind=NodeKind.CONFIG_KEY,
+                        label=f"{svc_name} network {net}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=fp),
+                        properties={"network": str(net)},
+                    ))
+            elif isinstance(networks, dict):
+                for net_name in networks:
+                    result.nodes.append(GraphNode(
+                        id=f"compose:{fp}:service:{svc_name}:network:{net_name}",
+                        kind=NodeKind.CONFIG_KEY,
+                        label=f"{svc_name} network {net_name}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=fp),
+                        properties={"network": str(net_name)},
+                    ))
+
+        return result

osscodeiq/detectors/config/github_actions.py

@@ -0,0 +1,150 @@
+"""GitHub Actions workflow detector for CI/CD pipeline 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,
+)
+
+
+def _is_github_actions_file(ctx: DetectorContext) -> bool:
+    """Check whether the file is a GitHub Actions workflow."""
+    return ".github/workflows/" in ctx.file_path
+
+
+class GitHubActionsDetector:
+    """Detects workflows, jobs, triggers, and job dependencies from GitHub Actions YAML files."""
+
+    name: str = "github_actions"
+    supported_languages: tuple[str, ...] = ("yaml",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        if not _is_github_actions_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
+        workflow_id = f"gha:{fp}"
+
+        # Workflow MODULE node
+        workflow_name = data.get("name", fp)
+        result.nodes.append(GraphNode(
+            id=workflow_id,
+            kind=NodeKind.MODULE,
+            label=str(workflow_name),
+            fqn=workflow_id,
+            module=ctx.module_name,
+            location=SourceLocation(file_path=fp),
+            properties={"workflow_file": fp},
+        ))
+
+        # Trigger events from "on:" key
+        on_triggers = data.get("on") or data.get(True)  # YAML parses bare "on" as True
+        if on_triggers is not None:
+            if isinstance(on_triggers, str):
+                # Simple form: on: push
+                result.nodes.append(GraphNode(
+                    id=f"gha:{fp}:trigger:{on_triggers}",
+                    kind=NodeKind.CONFIG_KEY,
+                    label=f"trigger: {on_triggers}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp),
+                    properties={"event": on_triggers},
+                ))
+            elif isinstance(on_triggers, list):
+                # List form: on: [push, pull_request]
+                for event in on_triggers:
+                    event_str = str(event)
+                    result.nodes.append(GraphNode(
+                        id=f"gha:{fp}:trigger:{event_str}",
+                        kind=NodeKind.CONFIG_KEY,
+                        label=f"trigger: {event_str}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=fp),
+                        properties={"event": event_str},
+                    ))
+            elif isinstance(on_triggers, dict):
+                # Dict form: on: { push: {branches: [main]}, ... }
+                for event_name, event_config in on_triggers.items():
+                    event_str = str(event_name)
+                    props: dict[str, Any] = {"event": event_str}
+                    if isinstance(event_config, dict):
+                        props["config"] = event_config
+                    result.nodes.append(GraphNode(
+                        id=f"gha:{fp}:trigger:{event_str}",
+                        kind=NodeKind.CONFIG_KEY,
+                        label=f"trigger: {event_str}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=fp),
+                        properties=props,
+                    ))
+
+        # Jobs
+        jobs = data.get("jobs")
+        if not isinstance(jobs, dict):
+            return result
+
+        job_ids: dict[str, str] = {}
+        for job_name in jobs:
+            job_ids[job_name] = f"gha:{fp}:job:{job_name}"
+
+        for job_name, job_def in jobs.items():
+            if not isinstance(job_def, dict):
+                continue
+
+            job_id = job_ids[job_name]
+
+            props = {}
+            runs_on = job_def.get("runs-on")
+            if runs_on is not None:
+                props["runs_on"] = runs_on if isinstance(runs_on, str) else str(runs_on)
+
+            result.nodes.append(GraphNode(
+                id=job_id,
+                kind=NodeKind.METHOD,
+                label=job_def.get("name", job_name),
+                fqn=job_id,
+                module=ctx.module_name,
+                location=SourceLocation(file_path=fp),
+                properties=props,
+            ))
+
+            # CONTAINS edge: workflow -> job
+            result.edges.append(GraphEdge(
+                source=workflow_id,
+                target=job_id,
+                kind=EdgeKind.CONTAINS,
+                label=f"workflow contains job {job_name}",
+            ))
+
+            # Job dependencies via "needs"
+            needs = job_def.get("needs")
+            if isinstance(needs, str):
+                needs = [needs]
+            if isinstance(needs, list):
+                for dep in needs:
+                    dep_str = str(dep)
+                    if 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}",
+                        ))
+
+        return result