osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/config/openapi.py

@@ -0,0 +1,194 @@
+"""Detector for OpenAPI 3.x and Swagger 2.0 specification files."""
+
+from __future__ import annotations
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+
+class OpenApiDetector:
+    """Detects API endpoints and schemas from OpenAPI/Swagger specifications."""
+
+    name: str = "openapi"
+    supported_languages: tuple[str, ...] = ("json", "yaml")
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        data = ctx.parsed_data
+        if not isinstance(data, dict) or not isinstance(data.get("data"), dict):
+            return result
+
+        spec = data["data"]
+
+        # Only trigger if this is an OpenAPI or Swagger spec
+        if "openapi" not in spec and "swagger" not in spec:
+            return result
+
+        filepath = ctx.file_path
+        config_id = f"api:{filepath}"
+
+        # Extract info metadata
+        info = spec.get("info") if isinstance(spec.get("info"), dict) else {}
+        api_title = info.get("title", filepath) if isinstance(info.get("title"), str) else filepath
+        api_version = info.get("version", "") if isinstance(info.get("version"), str) else ""
+        spec_version = spec.get("openapi") or spec.get("swagger") or ""
+
+        # CONFIG_FILE node for the spec
+        result.nodes.append(GraphNode(
+            id=config_id,
+            kind=NodeKind.CONFIG_FILE,
+            label=api_title,
+            fqn=filepath,
+            module=ctx.module_name,
+            location=SourceLocation(file_path=filepath),
+            properties={
+                "config_type": "openapi",
+                "api_title": api_title,
+                "api_version": api_version,
+                "spec_version": str(spec_version),
+            },
+        ))
+
+        # ENDPOINT nodes for each path + method combination
+        paths = spec.get("paths")
+        if isinstance(paths, dict):
+            for path, path_item in paths.items():
+                if not isinstance(path, str) or not isinstance(path_item, dict):
+                    continue
+                for method, operation in path_item.items():
+                    if not isinstance(method, str):
+                        continue
+                    # Skip non-HTTP-method keys (e.g. "parameters", "summary")
+                    if method.lower() not in (
+                        "get", "post", "put", "patch", "delete",
+                        "head", "options", "trace",
+                    ):
+                        continue
+                    method_upper = method.upper()
+                    endpoint_id = f"api:{filepath}:{method.lower()}:{path}"
+                    props: dict[str, object] = {
+                        "http_method": method_upper,
+                        "path": path,
+                    }
+                    if isinstance(operation, dict):
+                        op_id = operation.get("operationId")
+                        if isinstance(op_id, str):
+                            props["operation_id"] = op_id
+                        summary = operation.get("summary")
+                        if isinstance(summary, str):
+                            props["summary"] = summary
+
+                    result.nodes.append(GraphNode(
+                        id=endpoint_id,
+                        kind=NodeKind.ENDPOINT,
+                        label=f"{method_upper} {path}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=filepath),
+                        properties=props,
+                    ))
+                    result.edges.append(GraphEdge(
+                        source=config_id,
+                        target=endpoint_id,
+                        kind=EdgeKind.CONTAINS,
+                        label=f"{api_title} contains {method_upper} {path}",
+                    ))
+
+        # ENTITY nodes for schemas — OpenAPI 3.x and Swagger 2.0
+        schemas = _extract_schemas(spec)
+        for schema_name, schema_def in schemas.items():
+            if not isinstance(schema_name, str):
+                continue
+            schema_id = f"api:{filepath}:schema:{schema_name}"
+            schema_props: dict[str, object] = {"schema_name": schema_name}
+            if isinstance(schema_def, dict):
+                schema_type = schema_def.get("type")
+                if isinstance(schema_type, str):
+                    schema_props["schema_type"] = schema_type
+
+            result.nodes.append(GraphNode(
+                id=schema_id,
+                kind=NodeKind.ENTITY,
+                label=schema_name,
+                module=ctx.module_name,
+                location=SourceLocation(file_path=filepath),
+                properties=schema_props,
+            ))
+            result.edges.append(GraphEdge(
+                source=config_id,
+                target=schema_id,
+                kind=EdgeKind.CONTAINS,
+                label=f"{api_title} defines schema {schema_name}",
+            ))
+
+            # DEPENDS_ON edges for $ref references within this schema
+            if isinstance(schema_def, dict):
+                refs = _collect_refs(schema_def)
+                for ref in refs:
+                    ref_name = _ref_to_schema_name(ref)
+                    if ref_name and ref_name != schema_name and ref_name in schemas:
+                        result.edges.append(GraphEdge(
+                            source=schema_id,
+                            target=f"api:{filepath}:schema:{ref_name}",
+                            kind=EdgeKind.DEPENDS_ON,
+                            label=f"{schema_name} references {ref_name}",
+                        ))
+
+        return result
+
+
+def _extract_schemas(spec: dict) -> dict:
+    """Extract schema definitions from both OpenAPI 3.x and Swagger 2.0."""
+    # OpenAPI 3.x: components.schemas
+    components = spec.get("components")
+    if isinstance(components, dict):
+        schemas = components.get("schemas")
+        if isinstance(schemas, dict):
+            return schemas
+
+    # Swagger 2.0: definitions
+    definitions = spec.get("definitions")
+    if isinstance(definitions, dict):
+        return definitions
+
+    return {}
+
+
+def _collect_refs(obj: dict | list, _seen: set | None = None) -> list[str]:
+    """Recursively collect all $ref values from a schema definition."""
+    if _seen is None:
+        _seen = set()
+    refs: list[str] = []
+    obj_id = id(obj)
+    if obj_id in _seen:
+        return refs
+    _seen.add(obj_id)
+
+    if isinstance(obj, dict):
+        ref = obj.get("$ref")
+        if isinstance(ref, str):
+            refs.append(ref)
+        for value in obj.values():
+            if isinstance(value, (dict, list)):
+                refs.extend(_collect_refs(value, _seen))
+    elif isinstance(obj, list):
+        for item in obj:
+            if isinstance(item, (dict, list)):
+                refs.extend(_collect_refs(item, _seen))
+    return refs
+
+
+def _ref_to_schema_name(ref: str) -> str | None:
+    """Extract a schema name from a $ref string like '#/components/schemas/User'."""
+    if not ref.startswith("#/"):
+        return None
+    parts = ref.split("/")
+    if len(parts) >= 2:
+        return parts[-1]
+    return None

osscodeiq/detectors/config/package_json.py

@@ -0,0 +1,99 @@
+"""Detector for package.json files (npm/Node.js dependencies and scripts)."""
+
+from __future__ import annotations
+
+import os
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+
+class PackageJsonDetector:
+    """Detects module dependencies and scripts from package.json files."""
+
+    name: str = "package_json"
+    supported_languages: tuple[str, ...] = ("json",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        # Only trigger for files named exactly "package.json"
+        if os.path.basename(ctx.file_path) != "package.json":
+            return result
+
+        data = ctx.parsed_data
+        if not isinstance(data, dict) or not isinstance(data.get("data"), dict):
+            return result
+
+        pkg = data["data"]
+        filepath = ctx.file_path
+        module_id = f"npm:{filepath}"
+        pkg_name = pkg.get("name") or filepath
+
+        # MODULE node for the package
+        props: dict[str, object] = {"package_name": pkg_name}
+        version = pkg.get("version")
+        if version:
+            props["version"] = version
+
+        result.nodes.append(GraphNode(
+            id=module_id,
+            kind=NodeKind.MODULE,
+            label=pkg_name,
+            fqn=pkg_name,
+            module=ctx.module_name,
+            location=SourceLocation(file_path=filepath),
+            properties=props,
+        ))
+
+        # DEPENDS_ON edges for dependencies and devDependencies
+        for dep_key in ("dependencies", "devDependencies"):
+            deps = pkg.get(dep_key)
+            if not isinstance(deps, dict):
+                continue
+            for dep_name, dep_version in deps.items():
+                if not isinstance(dep_name, str):
+                    continue
+                edge_props: dict[str, object] = {"dep_type": dep_key}
+                if isinstance(dep_version, str):
+                    edge_props["version_spec"] = dep_version
+                result.edges.append(GraphEdge(
+                    source=module_id,
+                    target=f"npm:{dep_name}",
+                    kind=EdgeKind.DEPENDS_ON,
+                    label=f"{pkg_name} depends on {dep_name}",
+                    properties=edge_props,
+                ))
+
+        # METHOD nodes for each script
+        scripts = pkg.get("scripts")
+        if isinstance(scripts, dict):
+            for script_name, script_cmd in scripts.items():
+                if not isinstance(script_name, str):
+                    continue
+                script_id = f"npm:{filepath}:script:{script_name}"
+                script_props: dict[str, object] = {"script_name": script_name}
+                if isinstance(script_cmd, str):
+                    script_props["command"] = script_cmd
+                result.nodes.append(GraphNode(
+                    id=script_id,
+                    kind=NodeKind.METHOD,
+                    label=f"npm run {script_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=filepath),
+                    properties=script_props,
+                ))
+                result.edges.append(GraphEdge(
+                    source=module_id,
+                    target=script_id,
+                    kind=EdgeKind.CONTAINS,
+                    label=f"{pkg_name} contains script {script_name}",
+                ))
+
+        return result

osscodeiq/detectors/config/properties_detector.py

@@ -0,0 +1,108 @@
+"""Properties file detector for Java .properties and Spring configuration files."""
+
+from __future__ import annotations
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_DB_KEYWORDS = {"url", "jdbc", "datasource"}
+_MAX_KEYS = 200
+
+
+class PropertiesDetector:
+    """Detects property keys, Spring config markers, and database connections from .properties files."""
+
+    name: str = "properties"
+    supported_languages: tuple[str, ...] = ("properties",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        # parsed_data expected: {"type": "properties", "file": path, "data": {"key": "value", ...}}
+        if not isinstance(ctx.parsed_data, dict):
+            return result
+
+        if ctx.parsed_data.get("type") != "properties":
+            return result
+
+        data = ctx.parsed_data.get("data")
+        if not isinstance(data, dict):
+            return result
+
+        filepath = ctx.file_path
+        file_id = f"props:{filepath}"
+
+        # CONFIG_FILE node
+        result.nodes.append(GraphNode(
+            id=file_id,
+            kind=NodeKind.CONFIG_FILE,
+            label=filepath,
+            fqn=filepath,
+            module=ctx.module_name,
+            location=SourceLocation(
+                file_path=filepath,
+                line_start=1,
+            ),
+            properties={"format": "properties"},
+        ))
+
+        # Process keys (limit to avoid node explosion)
+        keys = list(data.items())[:_MAX_KEYS]
+
+        for key, value in keys:
+            if not isinstance(key, str):
+                continue
+
+            key_lower = key.lower()
+            key_id = f"props:{filepath}:{key}"
+
+            # Detect DB connection properties
+            is_db = any(kw in key_lower for kw in _DB_KEYWORDS)
+
+            if is_db:
+                props: dict[str, object] = {"key": key}
+                if isinstance(value, str):
+                    props["value"] = value
+
+                result.nodes.append(GraphNode(
+                    id=key_id,
+                    kind=NodeKind.DATABASE_CONNECTION,
+                    label=key,
+                    fqn=f"{filepath}:{key}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=filepath),
+                    properties=props,
+                ))
+            else:
+                props = {"key": key}
+                if isinstance(value, str):
+                    props["value"] = value
+
+                # Detect Spring config
+                if key.startswith("spring."):
+                    props["spring_config"] = True
+
+                result.nodes.append(GraphNode(
+                    id=key_id,
+                    kind=NodeKind.CONFIG_KEY,
+                    label=key,
+                    fqn=f"{filepath}:{key}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=filepath),
+                    properties=props,
+                ))
+
+            result.edges.append(GraphEdge(
+                source=file_id,
+                target=key_id,
+                kind=EdgeKind.CONTAINS,
+                label=f"{filepath} contains {key}",
+            ))
+
+        return result

osscodeiq/detectors/config/pyproject_toml.py

@@ -0,0 +1,169 @@
+"""Detector for pyproject.toml files (Python project metadata and dependencies)."""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib  # type: ignore[no-redef]
+    except ImportError:
+        tomllib = None  # type: ignore[assignment]
+
+
+class PyprojectTomlDetector:
+    """Detects Python project metadata, dependencies, and entry points from pyproject.toml."""
+
+    name: str = "pyproject_toml"
+    supported_languages: tuple[str, ...] = ("toml",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        # Only trigger for files named exactly "pyproject.toml"
+        if os.path.basename(ctx.file_path) != "pyproject.toml":
+            return result
+
+        if tomllib is None:
+            return result
+
+        try:
+            data = tomllib.loads(decode_text(ctx))
+        except Exception:
+            return result
+
+        if not isinstance(data, dict):
+            return result
+
+        filepath = ctx.file_path
+        module_id = f"pypi:{filepath}"
+
+        # Resolve project name from [project] or [tool.poetry]
+        project_section = data.get("project", {})
+        poetry_section = data.get("tool", {}).get("poetry", {})
+
+        pkg_name = (
+            project_section.get("name")
+            or poetry_section.get("name")
+            or filepath
+        )
+
+        # Module properties
+        props: dict[str, object] = {"package_name": pkg_name}
+        version = project_section.get("version") or poetry_section.get("version")
+        if version:
+            props["version"] = version
+        description = project_section.get("description") or poetry_section.get("description")
+        if description:
+            props["description"] = description
+
+        # MODULE node for the project
+        result.nodes.append(GraphNode(
+            id=module_id,
+            kind=NodeKind.MODULE,
+            label=pkg_name,
+            fqn=pkg_name,
+            module=ctx.module_name,
+            location=SourceLocation(file_path=filepath),
+            properties=props,
+        ))
+
+        # DEPENDS_ON edges for dependencies
+        # PEP 621 style: [project].dependencies is a list of strings
+        pep621_deps = project_section.get("dependencies", [])
+        if isinstance(pep621_deps, list):
+            for dep_spec in pep621_deps:
+                if not isinstance(dep_spec, str):
+                    continue
+                # Extract package name from spec like "requests>=2.0"
+                dep_name = _parse_dep_name(dep_spec)
+                if dep_name:
+                    result.edges.append(GraphEdge(
+                        source=module_id,
+                        target=f"pypi:{dep_name}",
+                        kind=EdgeKind.DEPENDS_ON,
+                        label=f"{pkg_name} depends on {dep_name}",
+                        properties={"dep_spec": dep_spec},
+                    ))
+
+        # Poetry style: [tool.poetry].dependencies is a dict
+        poetry_deps = poetry_section.get("dependencies", {})
+        if isinstance(poetry_deps, dict):
+            for dep_name, dep_version in poetry_deps.items():
+                if not isinstance(dep_name, str):
+                    continue
+                # Skip python itself
+                if dep_name.lower() == "python":
+                    continue
+                edge_props: dict[str, object] = {}
+                if isinstance(dep_version, str):
+                    edge_props["version_spec"] = dep_version
+                result.edges.append(GraphEdge(
+                    source=module_id,
+                    target=f"pypi:{dep_name}",
+                    kind=EdgeKind.DEPENDS_ON,
+                    label=f"{pkg_name} depends on {dep_name}",
+                    properties=edge_props,
+                ))
+
+        # CONFIG_DEFINITION nodes for entry points / scripts
+        scripts = project_section.get("scripts", {})
+        if not isinstance(scripts, dict):
+            scripts = {}
+        poetry_scripts = poetry_section.get("scripts", {})
+        if isinstance(poetry_scripts, dict):
+            scripts.update(poetry_scripts)
+
+        for script_name, script_target in scripts.items():
+            if not isinstance(script_name, str):
+                continue
+            script_id = f"pypi:{filepath}:script:{script_name}"
+            script_props: dict[str, object] = {"script_name": script_name}
+            if isinstance(script_target, str):
+                script_props["target"] = script_target
+
+            result.nodes.append(GraphNode(
+                id=script_id,
+                kind=NodeKind.CONFIG_DEFINITION,
+                label=script_name,
+                fqn=f"{pkg_name}:script:{script_name}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=filepath),
+                properties=script_props,
+            ))
+
+            result.edges.append(GraphEdge(
+                source=module_id,
+                target=script_id,
+                kind=EdgeKind.CONTAINS,
+                label=f"{pkg_name} defines script {script_name}",
+            ))
+
+        return result
+
+
+def _parse_dep_name(spec: str) -> str | None:
+    """Extract package name from a PEP 508 dependency specifier."""
+    # e.g. "requests>=2.0", "numpy", "black[jupyter]>=22.0"
+    spec = spec.strip()
+    if not spec:
+        return None
+    # Split on version specifiers or extras
+    for ch in ">=<![;@ ":
+        idx = spec.find(ch)
+        if idx > 0:
+            spec = spec[:idx]
+    return spec.strip() or None