osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/frontend/react_components.py

@@ -0,0 +1,148 @@
+"""React component and hook detector."""
+
+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 ReactComponentDetector:
+    """Detects React function/class components, custom hooks, and child rendering."""
+
+    name: str = "frontend.react_components"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript")
+
+    # Function component patterns
+    _EXPORT_DEFAULT_FUNC = re.compile(
+        r"export\s+default\s+function\s+([A-Z]\w*)\s*\("
+    )
+    _EXPORT_CONST_ARROW = re.compile(
+        r"export\s+const\s+([A-Z]\w*)\s*=\s*\("
+    )
+    _EXPORT_CONST_FC = re.compile(
+        r"export\s+const\s+([A-Z]\w*)\s*:\s*React\.FC"
+    )
+
+    # Class component patterns
+    _CLASS_EXTENDS_REACT_COMPONENT = re.compile(
+        r"class\s+([A-Z]\w*)\s+extends\s+React\.Component"
+    )
+    _CLASS_EXTENDS_COMPONENT = re.compile(
+        r"class\s+([A-Z]\w*)\s+extends\s+Component\b"
+    )
+
+    # Custom hook patterns (exported functions starting with "use")
+    _EXPORT_FUNC_HOOK = re.compile(
+        r"export\s+function\s+(use[A-Z]\w*)\s*\("
+    )
+    _EXPORT_CONST_HOOK = re.compile(
+        r"export\s+const\s+(use[A-Z]\w*)\s*=\s*"
+    )
+
+    # JSX child reference: <SomeComponent (uppercase tag names are components)
+    _JSX_TAG = re.compile(
+        r"<([A-Z]\w*)\b"
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        component_names: list[str] = []
+
+        # --- Function components ---
+        for pattern in (self._EXPORT_DEFAULT_FUNC, self._EXPORT_CONST_ARROW, self._EXPORT_CONST_FC):
+            for match in pattern.finditer(text):
+                name = match.group(1)
+                if name in [c for c, _ in [(n, None) for n in component_names]]:
+                    continue
+                line = text[: match.start()].count("\n") + 1
+                node_id = f"react:{ctx.file_path}:component:{name}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.COMPONENT,
+                        label=name,
+                        fqn=f"{ctx.file_path}::{name}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                        properties={
+                            "framework": "react",
+                            "component_type": "function",
+                        },
+                    )
+                )
+                component_names.append(name)
+
+        # --- Class components ---
+        for pattern in (self._CLASS_EXTENDS_REACT_COMPONENT, self._CLASS_EXTENDS_COMPONENT):
+            for match in pattern.finditer(text):
+                name = match.group(1)
+                if name in component_names:
+                    continue
+                line = text[: match.start()].count("\n") + 1
+                node_id = f"react:{ctx.file_path}:component:{name}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.COMPONENT,
+                        label=name,
+                        fqn=f"{ctx.file_path}::{name}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                        properties={
+                            "framework": "react",
+                            "component_type": "class",
+                        },
+                    )
+                )
+                component_names.append(name)
+
+        # --- Custom hooks ---
+        hook_names: list[str] = []
+        for pattern in (self._EXPORT_FUNC_HOOK, self._EXPORT_CONST_HOOK):
+            for match in pattern.finditer(text):
+                name = match.group(1)
+                if name in hook_names:
+                    continue
+                line = text[: match.start()].count("\n") + 1
+                node_id = f"react:{ctx.file_path}:hook:{name}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.HOOK,
+                        label=name,
+                        fqn=f"{ctx.file_path}::{name}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                        properties={
+                            "framework": "react",
+                        },
+                    )
+                )
+                hook_names.append(name)
+
+        # --- RENDERS edges (JSX child components) ---
+        all_detected = set(component_names) | set(hook_names)
+        child_names: set[str] = set()
+        for match in self._JSX_TAG.finditer(text):
+            tag = match.group(1)
+            if tag not in all_detected:
+                child_names.add(tag)
+
+        for comp in component_names:
+            source_id = f"react:{ctx.file_path}:component:{comp}"
+            for child in sorted(child_names):
+                result.edges.append(
+                    GraphEdge(
+                        source=source_id,
+                        target=child,
+                        kind=EdgeKind.RENDERS,
+                        label=f"{comp} renders {child}",
+                    )
+                )
+
+        return result

osscodeiq/detectors/frontend/svelte_components.py

@@ -0,0 +1,84 @@
+"""Svelte component detector."""
+
+from __future__ import annotations
+
+import re
+from pathlib import PurePosixPath
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import GraphNode, NodeKind, SourceLocation
+
+
+class SvelteComponentDetector:
+    """Detects Svelte component patterns: props, reactive statements, script blocks."""
+
+    name: str = "frontend.svelte_components"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript", "svelte")
+
+    # export let propName  or  export let propName = defaultValue
+    _PROP_PATTERN = re.compile(r"export\s+let\s+(\w+)")
+
+    # $: reactive statement
+    _REACTIVE_PATTERN = re.compile(r"^\s*\$:", re.MULTILINE)
+
+    # Detect Svelte script blocks (not used for HTML sanitization — structural detection only)
+    _SCRIPT_PATTERN = re.compile(r"^<script\b", re.MULTILINE)  # nosec
+
+    # Detect template content — any HTML tag that isn't script/style
+    _HTML_TEMPLATE_PATTERN = re.compile(r"^<(?!script\b|style\b|/)[a-zA-Z]\w*[\s>]", re.MULTILINE)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        has_props = bool(self._PROP_PATTERN.search(text))
+        has_reactive = bool(self._REACTIVE_PATTERN.search(text))
+        has_script = bool(self._SCRIPT_PATTERN.search(text))
+        has_template = bool(self._HTML_TEMPLATE_PATTERN.search(text))
+
+        # A file is a Svelte component if it has export let (props) or reactive
+        # statements, or if it has both a <script> block and HTML template content.
+        is_svelte = has_props or has_reactive or (has_script and has_template)
+
+        if not is_svelte:
+            return result
+
+        # Derive component name from filename (without extension)
+        component_name = PurePosixPath(ctx.file_path).stem
+
+        # Collect props
+        props: list[str] = []
+        for match in self._PROP_PATTERN.finditer(text):
+            props.append(match.group(1))
+
+        # Count reactive statements
+        reactive_count = len(self._REACTIVE_PATTERN.findall(text))
+
+        # Find the first significant line for location
+        first_line = 1
+        for pattern in (self._SCRIPT_PATTERN, self._PROP_PATTERN, self._REACTIVE_PATTERN):
+            m = pattern.search(text)
+            if m:
+                candidate = text[: m.start()].count("\n") + 1
+                first_line = min(first_line, candidate) if first_line > 1 else candidate
+                break
+
+        node_id = f"svelte:{ctx.file_path}:component:{component_name}"
+        result.nodes.append(
+            GraphNode(
+                id=node_id,
+                kind=NodeKind.COMPONENT,
+                label=component_name,
+                fqn=f"{ctx.file_path}::{component_name}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=first_line),
+                properties={
+                    "framework": "svelte",
+                    "props": props,
+                    "reactive_statements": reactive_count,
+                },
+            )
+        )
+
+        return result

osscodeiq/detectors/frontend/vue_components.py

@@ -0,0 +1,150 @@
+"""Vue component and composable detector."""
+
+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 GraphNode, NodeKind, SourceLocation
+
+
+class VueComponentDetector:
+    """Detects Vue components (Options API, Composition API, <script setup>) and composables."""
+
+    name: str = "frontend.vue_components"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript", "vue")
+
+    # defineComponent with name property
+    _DEFINE_COMPONENT_NAME = re.compile(
+        r"export\s+default\s+defineComponent\s*\(\s*\{[^}]*?name\s*:\s*['\"](\w+)['\"]",
+        re.DOTALL,
+    )
+
+    # Options API: export default { name: 'CompName'
+    _OPTIONS_API_NAME = re.compile(
+        r"export\s+default\s+\{\s*name\s*:\s*['\"](\w+)['\"]"
+    )
+
+    # <script setup> block detection
+    _SCRIPT_SETUP = re.compile(
+        r"<script\s+setup(?:\s+lang\s*=\s*['\"](?:ts|js)['\"])?\s*>"
+    )
+
+    # Composable patterns (functions starting with "use")
+    _EXPORT_FUNC_COMPOSABLE = re.compile(
+        r"export\s+function\s+(use[A-Z]\w*)\s*\("
+    )
+    _EXPORT_CONST_COMPOSABLE = re.compile(
+        r"export\s+const\s+(use[A-Z]\w*)\s*=\s*"
+    )
+
+    def _extract_script_setup_name(self, file_path: str) -> str | None:
+        """Derive component name from file path for <script setup> SFCs."""
+        # e.g. "components/UserProfile.vue" -> "UserProfile"
+        parts = file_path.replace("\\", "/").split("/")
+        filename = parts[-1]
+        if filename.endswith(".vue"):
+            return filename[: -len(".vue")]
+        return None
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        component_names: list[str] = []
+
+        # --- defineComponent with name ---
+        for match in self._DEFINE_COMPONENT_NAME.finditer(text):
+            name = match.group(1)
+            if name in component_names:
+                continue
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"vue:{ctx.file_path}:component:{name}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.COMPONENT,
+                    label=name,
+                    fqn=f"{ctx.file_path}::{name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "framework": "vue",
+                        "api_style": "composition",
+                    },
+                )
+            )
+            component_names.append(name)
+
+        # --- Options API ---
+        for match in self._OPTIONS_API_NAME.finditer(text):
+            name = match.group(1)
+            if name in component_names:
+                continue
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"vue:{ctx.file_path}:component:{name}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.COMPONENT,
+                    label=name,
+                    fqn=f"{ctx.file_path}::{name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "framework": "vue",
+                        "api_style": "options",
+                    },
+                )
+            )
+            component_names.append(name)
+
+        # --- <script setup> ---
+        for match in self._SCRIPT_SETUP.finditer(text):
+            comp_name = self._extract_script_setup_name(ctx.file_path)
+            if comp_name is None or comp_name in component_names:
+                continue
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"vue:{ctx.file_path}:component:{comp_name}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.COMPONENT,
+                    label=comp_name,
+                    fqn=f"{ctx.file_path}::{comp_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "framework": "vue",
+                        "api_style": "script_setup",
+                    },
+                )
+            )
+            component_names.append(comp_name)
+
+        # --- Composables (hooks) ---
+        hook_names: list[str] = []
+        for pattern in (self._EXPORT_FUNC_COMPOSABLE, self._EXPORT_CONST_COMPOSABLE):
+            for match in pattern.finditer(text):
+                name = match.group(1)
+                if name in hook_names:
+                    continue
+                line = text[: match.start()].count("\n") + 1
+                node_id = f"vue:{ctx.file_path}:hook:{name}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.HOOK,
+                        label=name,
+                        fqn=f"{ctx.file_path}::{name}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                        properties={
+                            "framework": "vue",
+                        },
+                    )
+                )
+                hook_names.append(name)
+
+        return result

osscodeiq/detectors/generic/__init__.py

@@ -0,0 +1 @@
+