osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/config/sql_structure.py

@@ -0,0 +1,155 @@
+"""SQL structure detector for tables, views, indexes, procedures, and foreign keys."""
+
+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,
+)
+
+_TABLE_RE = re.compile(
+    r'CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:\w+\.)?(\w+)',
+    re.IGNORECASE,
+)
+_VIEW_RE = re.compile(
+    r'CREATE\s+(?:OR\s+REPLACE\s+)?VIEW\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:\w+\.)?(\w+)',
+    re.IGNORECASE,
+)
+_INDEX_RE = re.compile(
+    r'CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:\w+\.)?(\w+)',
+    re.IGNORECASE,
+)
+_PROCEDURE_RE = re.compile(
+    r'CREATE\s+(?:OR\s+REPLACE\s+)?PROCEDURE\s+(?:\w+\.)?(\w+)',
+    re.IGNORECASE,
+)
+_FK_RE = re.compile(
+    r'REFERENCES\s+(?:\w+\.)?(\w+)',
+    re.IGNORECASE,
+)
+
+
+class SqlStructureDetector:
+    """Detects SQL structures: tables, views, indexes, procedures, and foreign key relationships."""
+
+    name: str = "sql_structure"
+    supported_languages: tuple[str, ...] = ("sql",)
+
+    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")
+
+        # Track current table for FK association
+        current_table: str | None = None
+        current_table_id: str | None = None
+
+        for i, line in enumerate(lines):
+            line_num = i + 1
+
+            # Tables
+            m = _TABLE_RE.search(line)
+            if m:
+                table_name = m.group(1)
+                current_table = table_name
+                current_table_id = f"sql:{filepath}:table:{table_name}"
+
+                result.nodes.append(GraphNode(
+                    id=current_table_id,
+                    kind=NodeKind.ENTITY,
+                    label=table_name,
+                    fqn=table_name,
+                    module=ctx.module_name,
+                    location=SourceLocation(
+                        file_path=filepath,
+                        line_start=line_num,
+                    ),
+                    properties={"entity_type": "table"},
+                ))
+                continue
+
+            # Views
+            m = _VIEW_RE.search(line)
+            if m:
+                view_name = m.group(1)
+                result.nodes.append(GraphNode(
+                    id=f"sql:{filepath}:view:{view_name}",
+                    kind=NodeKind.ENTITY,
+                    label=view_name,
+                    fqn=view_name,
+                    module=ctx.module_name,
+                    location=SourceLocation(
+                        file_path=filepath,
+                        line_start=line_num,
+                    ),
+                    properties={"entity_type": "view"},
+                ))
+                current_table = None
+                current_table_id = None
+                continue
+
+            # Indexes
+            m = _INDEX_RE.search(line)
+            if m:
+                index_name = m.group(1)
+                result.nodes.append(GraphNode(
+                    id=f"sql:{filepath}:index:{index_name}",
+                    kind=NodeKind.CONFIG_DEFINITION,
+                    label=index_name,
+                    fqn=index_name,
+                    module=ctx.module_name,
+                    location=SourceLocation(
+                        file_path=filepath,
+                        line_start=line_num,
+                    ),
+                    properties={"definition_type": "index"},
+                ))
+                continue
+
+            # Procedures
+            m = _PROCEDURE_RE.search(line)
+            if m:
+                proc_name = m.group(1)
+                result.nodes.append(GraphNode(
+                    id=f"sql:{filepath}:procedure:{proc_name}",
+                    kind=NodeKind.ENTITY,
+                    label=proc_name,
+                    fqn=proc_name,
+                    module=ctx.module_name,
+                    location=SourceLocation(
+                        file_path=filepath,
+                        line_start=line_num,
+                    ),
+                    properties={"entity_type": "procedure"},
+                ))
+                current_table = None
+                current_table_id = None
+                continue
+
+            # Foreign key references
+            m = _FK_RE.search(line)
+            if m and current_table_id:
+                ref_table = m.group(1)
+                ref_table_id = f"sql:{filepath}:table:{ref_table}"
+                result.edges.append(GraphEdge(
+                    source=current_table_id,
+                    target=ref_table_id,
+                    kind=EdgeKind.DEPENDS_ON,
+                    label=f"{current_table} references {ref_table}",
+                    properties={"relationship": "foreign_key"},
+                ))
+
+        return result

osscodeiq/detectors/config/toml_structure.py

@@ -0,0 +1,93 @@
+"""Generic TOML structure detector for all .toml files."""
+
+from __future__ import annotations
+
+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 TomlStructureDetector:
+    """Detects TOML file structures: sections, top-level keys, and file identity."""
+
+    name: str = "toml_structure"
+    supported_languages: tuple[str, ...] = ("toml",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        file_id = f"toml:{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": "toml"},
+        ))
+
+        if tomllib is None:
+            return result
+
+        # Parse TOML from raw content
+        try:
+            data = tomllib.loads(decode_text(ctx))
+        except Exception:
+            return result
+
+        if not isinstance(data, dict):
+            return result
+
+        for key, value in data.items():
+            key_str = str(key)
+
+            # Tables (sections) are dicts at top level
+            is_section = isinstance(value, dict)
+            key_id = f"toml:{ctx.file_path}:{key_str}"
+
+            props: dict[str, object] = {}
+            if is_section:
+                props["section"] = True
+
+            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,
+                ),
+                properties=props,
+            ))
+
+            result.edges.append(GraphEdge(
+                source=file_id,
+                target=key_id,
+                kind=EdgeKind.CONTAINS,
+                label=f"{ctx.file_path} contains {key_str}",
+            ))
+
+        return result

osscodeiq/detectors/config/tsconfig_json.py

@@ -0,0 +1,105 @@
+"""Detector for tsconfig.json files (TypeScript compiler configuration)."""
+
+from __future__ import annotations
+
+import os
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_TSCONFIG_RE = re.compile(r'^tsconfig(?:\..+)?\.json$')
+
+_TRACKED_COMPILER_OPTIONS = ("strict", "target", "module", "outDir", "rootDir")
+
+
+class TsconfigJsonDetector:
+    """Detects configuration structure from tsconfig.json files."""
+
+    name: str = "tsconfig_json"
+    supported_languages: tuple[str, ...] = ("json",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        # Only trigger for tsconfig.json or tsconfig.*.json
+        basename = os.path.basename(ctx.file_path)
+        if not _TSCONFIG_RE.match(basename):
+            return result
+
+        data = ctx.parsed_data
+        if not isinstance(data, dict) or not isinstance(data.get("data"), dict):
+            return result
+
+        cfg = data["data"]
+        filepath = ctx.file_path
+        config_id = f"tsconfig:{filepath}"
+
+        # CONFIG_FILE node
+        result.nodes.append(GraphNode(
+            id=config_id,
+            kind=NodeKind.CONFIG_FILE,
+            label=basename,
+            fqn=filepath,
+            module=ctx.module_name,
+            location=SourceLocation(file_path=filepath),
+            properties={"config_type": "tsconfig"},
+        ))
+
+        # DEPENDS_ON edge for "extends"
+        extends = cfg.get("extends")
+        if isinstance(extends, str) and extends:
+            result.edges.append(GraphEdge(
+                source=config_id,
+                target=extends,
+                kind=EdgeKind.DEPENDS_ON,
+                label=f"{basename} extends {extends}",
+                properties={"relation": "extends"},
+            ))
+
+        # DEPENDS_ON edges for "references"
+        references = cfg.get("references")
+        if isinstance(references, list):
+            for ref in references:
+                if not isinstance(ref, dict):
+                    continue
+                ref_path = ref.get("path")
+                if isinstance(ref_path, str) and ref_path:
+                    result.edges.append(GraphEdge(
+                        source=config_id,
+                        target=ref_path,
+                        kind=EdgeKind.DEPENDS_ON,
+                        label=f"{basename} references {ref_path}",
+                        properties={"relation": "reference"},
+                    ))
+
+        # CONFIG_KEY nodes for key compiler options
+        compiler_options = cfg.get("compilerOptions")
+        if isinstance(compiler_options, dict):
+            for opt in _TRACKED_COMPILER_OPTIONS:
+                if opt not in compiler_options:
+                    continue
+                value = compiler_options[opt]
+                key_id = f"tsconfig:{filepath}:option:{opt}"
+                result.nodes.append(GraphNode(
+                    id=key_id,
+                    kind=NodeKind.CONFIG_KEY,
+                    label=f"compilerOptions.{opt}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=filepath),
+                    properties={"key": opt, "value": value},
+                ))
+                result.edges.append(GraphEdge(
+                    source=config_id,
+                    target=key_id,
+                    kind=EdgeKind.CONTAINS,
+                    label=f"{basename} defines {opt}",
+                ))
+
+        return result

osscodeiq/detectors/config/yaml_structure.py

@@ -0,0 +1,82 @@
+"""Generic YAML structure detector for all .yaml/.yml files."""
+
+from __future__ import annotations
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+
+class YamlStructureDetector:
+    """Detects YAML file structures: top-level keys and file identity."""
+
+    name: str = "yaml_structure"
+    supported_languages: tuple[str, ...] = ("yaml",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+
+        file_id = f"yaml:{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": "yaml"},
+        ))
+
+        if not isinstance(ctx.parsed_data, dict):
+            return result
+
+        doc_type = ctx.parsed_data.get("type", "")
+
+        # Collect all top-level keys from documents
+        top_level_keys: set[str] = set()
+
+        if doc_type == "yaml_multi":
+            # Multi-document YAML: iterate over documents list
+            documents = ctx.parsed_data.get("documents", [])
+            for doc in documents:
+                if isinstance(doc, dict):
+                    top_level_keys.update(str(k) for k in doc)
+        elif doc_type == "yaml":
+            # Single-document YAML
+            data = ctx.parsed_data.get("data")
+            if isinstance(data, dict):
+                top_level_keys.update(str(k) for k in data)
+
+        # Create CONFIG_KEY nodes for top-level keys
+        for key_str in sorted(top_level_keys):
+            key_id = f"yaml:{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

osscodeiq/detectors/cpp/cpp_structures.py

@@ -0,0 +1,192 @@
+"""C/C++ structures detector for classes, structs, namespaces, functions, and enums."""
+
+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_RE = re.compile(
+    r'(?:template\s*<[^>]*>\s*)?class\s+(\w+)(?:\s*:\s*(?:public|protected|private)\s+(\w+))?'
+)
+_STRUCT_RE = re.compile(
+    r'struct\s+(\w+)(?:\s*:\s*(?:public|protected|private)\s+(\w+))?\s*\{'
+)
+_NAMESPACE_RE = re.compile(r'namespace\s+(\w+)\s*\{')
+_FUNC_RE = re.compile(
+    r'^(?:[\w:*&<>\s]+)\s+(\w+)\s*\([^)]*\)\s*(?:const\s*)?\{', re.MULTILINE
+)
+_INCLUDE_RE = re.compile(r'#include\s+[<"]([^>"]+)[>"]')
+_ENUM_RE = re.compile(r'enum\s+(?:class\s+)?(\w+)')
+
+
+def _is_forward_declaration(line: str) -> bool:
+    """Check if a line is a forward declaration (ends with ; but has no body)."""
+    stripped = line.rstrip()
+    # A line ending with ; that contains { is a single-line definition, not a forward decl
+    return stripped.endswith(';') and '{' not in stripped
+
+
+class CppStructuresDetector:
+    """Detects C/C++ structural elements: classes, structs, namespaces, functions, enums."""
+
+    name: str = "cpp_structures"
+    supported_languages: tuple[str, ...] = ("cpp", "c")
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        file_node_id = ctx.file_path
+
+        # Detect #include directives
+        for i, line in enumerate(lines):
+            m = _INCLUDE_RE.search(line)
+            if not m:
+                continue
+            included = m.group(1)
+            result.edges.append(GraphEdge(
+                source=ctx.file_path,
+                target=included,
+                kind=EdgeKind.IMPORTS,
+                label=f"{ctx.file_path} includes {included}",
+            ))
+
+        # Detect namespace declarations
+        for i, line in enumerate(lines):
+            m = _NAMESPACE_RE.search(line)
+            if not m:
+                continue
+            ns_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{ns_name}",
+                kind=NodeKind.MODULE,
+                label=ns_name,
+                fqn=ns_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=i + 1,
+                ),
+                properties={"namespace": True},
+            ))
+
+        # Detect class declarations (including template classes)
+        for i, line in enumerate(lines):
+            m = _CLASS_RE.search(line)
+            if not m:
+                continue
+            # Skip forward declarations
+            if _is_forward_declaration(line):
+                continue
+            class_name = m.group(1)
+            base_class = m.group(2)
+            is_template = 'template' in line[:m.start() + len(m.group(0))]
+
+            props: dict = {}
+            if is_template:
+                props["is_template"] = True
+
+            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=i + 1,
+                ),
+                properties=props,
+            ))
+
+            if base_class:
+                result.edges.append(GraphEdge(
+                    source=node_id,
+                    target=base_class,
+                    kind=EdgeKind.EXTENDS,
+                    label=f"{class_name} extends {base_class}",
+                ))
+
+        # Detect struct declarations
+        for i, line in enumerate(lines):
+            m = _STRUCT_RE.search(line)
+            if not m:
+                continue
+            if _is_forward_declaration(line):
+                continue
+            struct_name = m.group(1)
+            base_struct = m.group(2)
+
+            node_id = f"{ctx.file_path}:{struct_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.CLASS,
+                label=struct_name,
+                fqn=struct_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=i + 1,
+                ),
+                properties={"struct": True},
+            ))
+
+            if base_struct:
+                result.edges.append(GraphEdge(
+                    source=node_id,
+                    target=base_struct,
+                    kind=EdgeKind.EXTENDS,
+                    label=f"{struct_name} extends {base_struct}",
+                ))
+
+        # Detect enum declarations
+        for i, line in enumerate(lines):
+            m = _ENUM_RE.search(line)
+            if not m:
+                continue
+            if _is_forward_declaration(line):
+                continue
+            enum_name = m.group(1)
+
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{enum_name}",
+                kind=NodeKind.ENUM,
+                label=enum_name,
+                fqn=enum_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=i + 1,
+                ),
+            ))
+
+        # Detect file-scope function definitions
+        for m in _FUNC_RE.finditer(text):
+            func_name = m.group(1)
+            # Compute line number from character offset
+            line_num = text[:m.start()].count("\n") + 1
+
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{func_name}",
+                kind=NodeKind.METHOD,
+                label=func_name,
+                fqn=func_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=line_num,
+                ),
+            ))
+
+        return result