osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/docs/markdown_structure.py

@@ -0,0 +1,117 @@
+"""Markdown structure detector for headings and internal links."""
+
+from __future__ import annotations
+
+import os
+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,
+)
+
+_HEADING_RE = re.compile(r'^(#{1,6})\s+(.+)$', re.MULTILINE)
+_LINK_RE = re.compile(r'\[([^\]]+)\]\(([^)]+)\)')
+_EXTERNAL_RE = re.compile(r'^https?://')
+
+
+class MarkdownStructureDetector:
+    """Detects Markdown headings and internal file links."""
+
+    name: str = "markdown_structure"
+    supported_languages: tuple[str, ...] = ("markdown",)
+
+    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")
+
+        # Find first H1 for module label
+        first_h1: str | None = None
+        for line in lines:
+            m = _HEADING_RE.match(line)
+            if m and len(m.group(1)) == 1:
+                first_h1 = m.group(2).strip()
+                break
+
+        module_label = first_h1 or os.path.basename(filepath)
+        module_id = f"md:{filepath}"
+
+        # MODULE node for the file
+        result.nodes.append(GraphNode(
+            id=module_id,
+            kind=NodeKind.MODULE,
+            label=module_label,
+            fqn=filepath,
+            module=ctx.module_name,
+            location=SourceLocation(
+                file_path=filepath,
+                line_start=1,
+            ),
+        ))
+
+        # CONFIG_KEY nodes for each heading
+        for i, line in enumerate(lines):
+            m = _HEADING_RE.match(line)
+            if not m:
+                continue
+            level = len(m.group(1))
+            heading_text = m.group(2).strip()
+            line_num = i + 1
+
+            heading_id = f"md:{filepath}:heading:{line_num}"
+            result.nodes.append(GraphNode(
+                id=heading_id,
+                kind=NodeKind.CONFIG_KEY,
+                label=heading_text,
+                fqn=f"{filepath}:heading:{heading_text}",
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=filepath,
+                    line_start=line_num,
+                ),
+                properties={"level": level, "text": heading_text},
+            ))
+
+            result.edges.append(GraphEdge(
+                source=module_id,
+                target=heading_id,
+                kind=EdgeKind.CONTAINS,
+                label=f"{filepath} contains heading {heading_text}",
+            ))
+
+        # DEPENDS_ON edges for internal links
+        for i, line in enumerate(lines):
+            for m in _LINK_RE.finditer(line):
+                link_text = m.group(1)
+                link_target = m.group(2)
+
+                # Skip external URLs
+                if _EXTERNAL_RE.match(link_target):
+                    continue
+
+                # Strip anchor fragments
+                link_path = link_target.split("#")[0]
+                if not link_path:
+                    continue
+
+                result.edges.append(GraphEdge(
+                    source=module_id,
+                    target=link_path,
+                    kind=EdgeKind.DEPENDS_ON,
+                    label=f"{filepath} links to {link_path}",
+                    properties={"link_text": link_text},
+                ))
+
+        return result

osscodeiq/detectors/frontend/angular_components.py

@@ -0,0 +1,177 @@
+"""Angular component, service, directive, pipe, and module 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 AngularComponentDetector:
+    """Detects Angular @Component, @Injectable, @Directive, @Pipe, and @NgModule decorators."""
+
+    name: str = "frontend.angular_components"
+    supported_languages: tuple[str, ...] = ("typescript",)
+
+    # @Component({ selector: 'app-name' }) followed by class Name
+    _COMPONENT_DECORATOR = re.compile(
+        r"@Component\s*\(\s*\{.*?selector\s*:\s*['\"]([^'\"]+)['\"].*?\}\s*\)\s*\n?\s*(?:export\s+)?class\s+(\w+)",
+        re.DOTALL,
+    )
+
+    # @Injectable({ providedIn: 'root' }) followed by class Name
+    _INJECTABLE_DECORATOR = re.compile(
+        r"@Injectable\s*\(\s*\{.*?providedIn\s*:\s*['\"](\w+)['\"].*?\}\s*\)\s*\n?\s*(?:export\s+)?class\s+(\w+)",
+        re.DOTALL,
+    )
+
+    # @Directive({ selector: '[appHighlight]' }) followed by class Name
+    _DIRECTIVE_DECORATOR = re.compile(
+        r"@Directive\s*\(\s*\{.*?selector\s*:\s*['\"]([^'\"]+)['\"].*?\}\s*\)\s*\n?\s*(?:export\s+)?class\s+(\w+)",
+        re.DOTALL,
+    )
+
+    # @Pipe({ name: 'pipeName' }) followed by class Name
+    _PIPE_DECORATOR = re.compile(
+        r"@Pipe\s*\(\s*\{.*?name\s*:\s*['\"](\w+)['\"].*?\}\s*\)\s*\n?\s*(?:export\s+)?class\s+(\w+)",
+        re.DOTALL,
+    )
+
+    # @NgModule({ declarations: [...] }) followed by class Name
+    _NGMODULE_DECORATOR = re.compile(
+        r"@NgModule\s*\(\s*\{.*?\}\s*\)\s*\n?\s*(?:export\s+)?class\s+(\w+)",
+        re.DOTALL,
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        seen: set[str] = set()
+
+        # --- @Component ---
+        for match in self._COMPONENT_DECORATOR.finditer(text):
+            selector = match.group(1)
+            class_name = match.group(2)
+            if class_name in seen:
+                continue
+            seen.add(class_name)
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"angular:{ctx.file_path}:component:{class_name}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.COMPONENT,
+                    label=class_name,
+                    fqn=f"{ctx.file_path}::{class_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "framework": "angular",
+                        "selector": selector,
+                        "decorator": "Component",
+                    },
+                )
+            )
+
+        # --- @Injectable (services) ---
+        for match in self._INJECTABLE_DECORATOR.finditer(text):
+            provided_in = match.group(1)
+            class_name = match.group(2)
+            if class_name in seen:
+                continue
+            seen.add(class_name)
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"angular:{ctx.file_path}:service:{class_name}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.MIDDLEWARE,
+                    label=class_name,
+                    fqn=f"{ctx.file_path}::{class_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "framework": "angular",
+                        "provided_in": provided_in,
+                        "decorator": "Injectable",
+                    },
+                )
+            )
+
+        # --- @Directive ---
+        for match in self._DIRECTIVE_DECORATOR.finditer(text):
+            selector = match.group(1)
+            class_name = match.group(2)
+            if class_name in seen:
+                continue
+            seen.add(class_name)
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"angular:{ctx.file_path}:component:{class_name}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.COMPONENT,
+                    label=class_name,
+                    fqn=f"{ctx.file_path}::{class_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "framework": "angular",
+                        "selector": selector,
+                        "decorator": "Directive",
+                    },
+                )
+            )
+
+        # --- @Pipe ---
+        for match in self._PIPE_DECORATOR.finditer(text):
+            pipe_name = match.group(1)
+            class_name = match.group(2)
+            if class_name in seen:
+                continue
+            seen.add(class_name)
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"angular:{ctx.file_path}:component:{class_name}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.COMPONENT,
+                    label=class_name,
+                    fqn=f"{ctx.file_path}::{class_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "framework": "angular",
+                        "pipe_name": pipe_name,
+                        "decorator": "Pipe",
+                    },
+                )
+            )
+
+        # --- @NgModule ---
+        for match in self._NGMODULE_DECORATOR.finditer(text):
+            class_name = match.group(1)
+            if class_name in seen:
+                continue
+            seen.add(class_name)
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"angular:{ctx.file_path}:component:{class_name}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.COMPONENT,
+                    label=class_name,
+                    fqn=f"{ctx.file_path}::{class_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "framework": "angular",
+                        "decorator": "NgModule",
+                    },
+                )
+            )
+
+        return result

osscodeiq/detectors/frontend/frontend_routes.py

@@ -0,0 +1,259 @@
+"""Frontend route detector for React Router, Vue Router, Next.js, and Angular."""
+
+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 EdgeKind, GraphEdge, GraphNode, NodeKind, SourceLocation
+
+
+class FrontendRouteDetector:
+    """Detects frontend routing definitions across major frameworks."""
+
+    name: str = "frontend.frontend_routes"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript", "vue", "svelte")
+
+    # --- React Router patterns ---
+    # <Route path="/foo" component={Bar}> or <Route path="/foo" element={<Bar />}>
+    _REACT_ROUTE_COMPONENT = re.compile(
+        r"<Route\s+[^>]*?path\s*=\s*[\"']([^\"']+)[\"'][^>]*?"
+        r"component\s*=\s*\{(\w+)\}",
+    )
+    _REACT_ROUTE_ELEMENT = re.compile(
+        r"<Route\s+[^>]*?path\s*=\s*[\"']([^\"']+)[\"'][^>]*?"
+        r"element\s*=\s*\{<(\w+)",
+    )
+    # <Route path="/foo"> (no component/element yet, or nested)
+    _REACT_ROUTE_BARE = re.compile(
+        r"<Route\s+[^>]*?path\s*=\s*[\"']([^\"']+)[\"']",
+    )
+
+    # --- Vue Router patterns ---
+    # { path: '/foo', component: Bar } or { path: '/foo', component: () => import(...) }
+    _VUE_ROUTE = re.compile(
+        r"\{\s*path\s*:\s*['\"]([^'\"]+)['\"]"
+        r"(?:.*?component\s*:\s*(\w+))?"
+    )
+    _VUE_CREATE_ROUTER = re.compile(r"createRouter\s*\(")
+    _VUE_ROUTES_ARRAY = re.compile(r"\broutes\s*:\s*\[")
+
+    # --- Angular patterns ---
+    _ANGULAR_ROUTE = re.compile(
+        r"\{\s*path\s*:\s*['\"]([^'\"]+)['\"]"
+        r"(?:.*?component\s*:\s*(\w+))?"
+    )
+    _ANGULAR_ROUTER_MODULE = re.compile(
+        r"RouterModule\.for(?:Root|Child)\s*\("
+    )
+
+    # --- Next.js file-based routing ---
+    # pages/index.tsx, pages/about.tsx, pages/users/[id].tsx
+    _NEXTJS_PAGES = re.compile(r"^pages/(.+)\.(tsx|ts|jsx|js)$")
+    # app/**/page.tsx (App Router)
+    _NEXTJS_APP = re.compile(r"^app/(.+)/page\.(tsx|ts|jsx|js)$")
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        self._detect_nextjs_file_routes(ctx, result)
+        self._detect_react_router(ctx, text, result)
+        self._detect_vue_router(ctx, text, result)
+        self._detect_angular_router(ctx, text, result)
+
+        return result
+
+    def _detect_nextjs_file_routes(
+        self, ctx: DetectorContext, result: DetectorResult
+    ) -> None:
+        """Detect Next.js file-based routes from file path alone."""
+        fp = ctx.file_path
+
+        match = self._NEXTJS_PAGES.match(fp)
+        if match:
+            raw = match.group(1)
+            route_path = self._nextjs_pages_path(raw)
+            node_id = f"route:{fp}:nextjs:{route_path}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.ENDPOINT,
+                    label=f"page {route_path}",
+                    fqn=f"{fp}::page",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp, line_start=1),
+                    properties={
+                        "protocol": "frontend_route",
+                        "framework": "nextjs",
+                        "route_path": route_path,
+                    },
+                )
+            )
+            return
+
+        match = self._NEXTJS_APP.match(fp)
+        if match:
+            raw = match.group(1)
+            route_path = "/" + raw.replace("\\", "/")
+            node_id = f"route:{fp}:nextjs:{route_path}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.ENDPOINT,
+                    label=f"page {route_path}",
+                    fqn=f"{fp}::page",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp, line_start=1),
+                    properties={
+                        "protocol": "frontend_route",
+                        "framework": "nextjs",
+                        "route_path": route_path,
+                    },
+                )
+            )
+
+    @staticmethod
+    def _nextjs_pages_path(raw: str) -> str:
+        """Convert a pages-directory relative path to a route path."""
+        # pages/index -> /
+        # pages/about -> /about
+        # pages/users/[id] -> /users/[id]
+        parts = raw.replace("\\", "/").split("/")
+        # Remove trailing 'index'
+        if parts and parts[-1] == "index":
+            parts = parts[:-1]
+        route = "/" + "/".join(parts) if parts else "/"
+        return route
+
+    def _detect_react_router(
+        self, ctx: DetectorContext, text: str, result: DetectorResult
+    ) -> None:
+        """Detect React Router route definitions."""
+        seen_paths: set[str] = set()
+
+        # <Route path="..." component={Comp}>
+        for match in self._REACT_ROUTE_COMPONENT.finditer(text):
+            path = match.group(1)
+            component = match.group(2)
+            if path in seen_paths:
+                continue
+            seen_paths.add(path)
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"route:{ctx.file_path}:react:{path}"
+            result.nodes.append(self._route_node(
+                node_id, path, "react", ctx, line,
+            ))
+            # RENDERS edge to component
+            result.edges.append(GraphEdge(
+                source=node_id,
+                target=component,
+                kind=EdgeKind.RENDERS,
+                label=f"renders {component}",
+            ))
+
+        # <Route path="..." element={<Comp />}>
+        for match in self._REACT_ROUTE_ELEMENT.finditer(text):
+            path = match.group(1)
+            component = match.group(2)
+            if path in seen_paths:
+                continue
+            seen_paths.add(path)
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"route:{ctx.file_path}:react:{path}"
+            result.nodes.append(self._route_node(
+                node_id, path, "react", ctx, line,
+            ))
+            result.edges.append(GraphEdge(
+                source=node_id,
+                target=component,
+                kind=EdgeKind.RENDERS,
+                label=f"renders {component}",
+            ))
+
+        # Bare <Route path="..."> (no component/element captured above)
+        for match in self._REACT_ROUTE_BARE.finditer(text):
+            path = match.group(1)
+            if path in seen_paths:
+                continue
+            seen_paths.add(path)
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"route:{ctx.file_path}:react:{path}"
+            result.nodes.append(self._route_node(
+                node_id, path, "react", ctx, line,
+            ))
+
+    def _detect_vue_router(
+        self, ctx: DetectorContext, text: str, result: DetectorResult
+    ) -> None:
+        """Detect Vue Router route definitions."""
+        has_create_router = bool(self._VUE_CREATE_ROUTER.search(text))
+        has_routes_array = bool(self._VUE_ROUTES_ARRAY.search(text))
+
+        if not (has_create_router or has_routes_array):
+            return
+
+        for match in self._VUE_ROUTE.finditer(text):
+            path = match.group(1)
+            component = match.group(2)
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"route:{ctx.file_path}:vue:{path}"
+            result.nodes.append(self._route_node(
+                node_id, path, "vue", ctx, line,
+            ))
+            if component:
+                result.edges.append(GraphEdge(
+                    source=node_id,
+                    target=component,
+                    kind=EdgeKind.RENDERS,
+                    label=f"renders {component}",
+                ))
+
+    def _detect_angular_router(
+        self, ctx: DetectorContext, text: str, result: DetectorResult
+    ) -> None:
+        """Detect Angular Router route definitions."""
+        has_router_module = bool(self._ANGULAR_ROUTER_MODULE.search(text))
+
+        if not has_router_module:
+            return
+
+        for match in self._ANGULAR_ROUTE.finditer(text):
+            path = match.group(1)
+            component = match.group(2)
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"route:{ctx.file_path}:angular:{path}"
+            result.nodes.append(self._route_node(
+                node_id, path, "angular", ctx, line,
+            ))
+            if component:
+                result.edges.append(GraphEdge(
+                    source=node_id,
+                    target=component,
+                    kind=EdgeKind.RENDERS,
+                    label=f"renders {component}",
+                ))
+
+    @staticmethod
+    def _route_node(
+        node_id: str,
+        path: str,
+        framework: str,
+        ctx: DetectorContext,
+        line: int,
+    ) -> GraphNode:
+        return GraphNode(
+            id=node_id,
+            kind=NodeKind.ENDPOINT,
+            label=f"route {path}",
+            fqn=f"{ctx.file_path}::route:{path}",
+            module=ctx.module_name,
+            location=SourceLocation(file_path=ctx.file_path, line_start=line),
+            properties={
+                "protocol": "frontend_route",
+                "framework": framework,
+                "route_path": path,
+            },
+        )