osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/typescript/remix_routes.py

@@ -0,0 +1,160 @@
+"""Remix route 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 RemixRouteDetector:
+    """Detects Remix loader, action exports, default component exports, and data hooks."""
+
+    name: str = "remix_routes"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript")
+
+    # export async function loader( or export function loader(
+    _LOADER_PATTERN = re.compile(
+        r"export\s+(?:async\s+)?function\s+loader\s*\("
+    )
+
+    # export async function action( or export function action(
+    _ACTION_PATTERN = re.compile(
+        r"export\s+(?:async\s+)?function\s+action\s*\("
+    )
+
+    # export default function ComponentName( or export default function(
+    _DEFAULT_COMPONENT_PATTERN = re.compile(
+        r"export\s+default\s+function\s+(\w*)\s*\("
+    )
+
+    # useLoaderData() or useActionData()
+    _USE_LOADER_DATA = re.compile(r"\buseLoaderData\s*\(\s*\)")
+    _USE_ACTION_DATA = re.compile(r"\buseActionData\s*\(\s*\)")
+
+    def _derive_route_path(self, file_path: str) -> str | None:
+        """Derive route path from Remix file path convention.
+
+        app/routes/users.tsx         -> /users
+        app/routes/users.$id.tsx     -> /users/:id
+        app/routes/_index.tsx        -> /
+        app/routes/users_.tsx        -> /users
+        app/routes/blog.articles.tsx -> /blog/articles
+        """
+        # Only process files under app/routes/
+        if "app/routes/" not in file_path:
+            return None
+
+        # Extract the route segment after app/routes/
+        segment = file_path.split("app/routes/", 1)[1]
+
+        # Remove file extension
+        segment = re.sub(r"\.(tsx?|jsx?)$", "", segment)
+
+        # Handle _index convention
+        if segment == "_index" or segment.endswith("/_index"):
+            prefix = segment.rsplit("_index", 1)[0].rstrip("/.")
+            if not prefix:
+                return "/"
+            return "/" + prefix.replace(".", "/")
+
+        # Replace Remix $ params with :param style
+        parts = segment.split(".")
+        path_parts = []
+        for part in parts:
+            if part.startswith("$"):
+                path_parts.append(f":{part[1:]}")
+            elif part.endswith("_"):
+                # Pathless layout route - include the segment but it's a layout
+                path_parts.append(part.rstrip("_"))
+            else:
+                path_parts.append(part)
+
+        return "/" + "/".join(path_parts)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        route_path = self._derive_route_path(ctx.file_path)
+
+        # Detect loader exports
+        for match in self._LOADER_PATTERN.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"remix:{ctx.file_path}:loader:{line}"
+            properties: dict = {
+                "framework": "remix",
+                "type": "loader",
+                "http_method": "GET",
+            }
+            if route_path:
+                properties["route_path"] = route_path
+
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.ENDPOINT,
+                    label=f"loader {route_path or ctx.file_path}",
+                    fqn=f"{ctx.file_path}::loader",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties=properties,
+                )
+            )
+
+        # Detect action exports
+        for match in self._ACTION_PATTERN.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"remix:{ctx.file_path}:action:{line}"
+            properties = {
+                "framework": "remix",
+                "type": "action",
+                "http_method": "POST",
+            }
+            if route_path:
+                properties["route_path"] = route_path
+
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.ENDPOINT,
+                    label=f"action {route_path or ctx.file_path}",
+                    fqn=f"{ctx.file_path}::action",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties=properties,
+                )
+            )
+
+        # Detect default component export
+        for match in self._DEFAULT_COMPONENT_PATTERN.finditer(text):
+            comp_name = match.group(1) or "default"
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"remix:{ctx.file_path}:component:{comp_name}"
+            properties: dict = {
+                "framework": "remix",
+                "type": "component",
+            }
+            if route_path:
+                properties["route_path"] = route_path
+
+            # Check for data hook usage
+            if self._USE_LOADER_DATA.search(text):
+                properties["uses_loader_data"] = True
+            if self._USE_ACTION_DATA.search(text):
+                properties["uses_action_data"] = True
+
+            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=properties,
+                )
+            )
+
+        return result

osscodeiq/detectors/typescript/sequelize_orm.py

@@ -0,0 +1,136 @@
+"""Sequelize ORM detector for TypeScript/JavaScript."""
+
+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 SequelizeORMDetector:
+    """Detects Sequelize ORM usage patterns in TypeScript/JavaScript files."""
+
+    name: str = "sequelize_orm"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript")
+
+    # sequelize.define('ModelName', { ... })
+    _DEFINE_RE = re.compile(r"sequelize\.define\s*\(\s*['\"](\w+)['\"]")
+    # class User extends Model { ... }
+    _EXTENDS_MODEL_RE = re.compile(r"class\s+(\w+)\s+extends\s+Model\s*\{")
+    # Model.init({ ... }, { sequelize })
+    _MODEL_INIT_RE = re.compile(r"(\w+)\.init\s*\(\s*\{")
+    # new Sequelize( or new Sequelize.Sequelize(
+    _CONNECTION_RE = re.compile(r"new\s+Sequelize(?:\.Sequelize)?\s*\(")
+    # Model.belongsTo(, Model.hasMany(, etc.
+    _ASSOCIATION_RE = re.compile(
+        r"(\w+)\.(belongsTo|hasMany|hasOne|belongsToMany)\s*\(\s*(\w+)"
+    )
+    # Model.findAll(, Model.findOne(, Model.create(, etc.
+    _QUERY_RE = re.compile(
+        r"(\w+)\.(findAll|findOne|findByPk|findOrCreate|create|bulkCreate|update|destroy|count|max|min|sum)\s*\("
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        seen_models: dict[str, str] = {}
+
+        # Detect Sequelize connection -> DATABASE_CONNECTION
+        for match in self._CONNECTION_RE.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"sequelize:{ctx.file_path}:connection:{line}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.DATABASE_CONNECTION,
+                    label="Sequelize",
+                    fqn=f"{ctx.file_path}::Sequelize",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={"framework": "sequelize"},
+                )
+            )
+
+        # Detect sequelize.define('ModelName', { ... }) -> ENTITY
+        for match in self._DEFINE_RE.finditer(text):
+            model_name = match.group(1)
+            line = text[: match.start()].count("\n") + 1
+            model_id = f"sequelize:{ctx.file_path}:model:{model_name}"
+            seen_models[model_name] = model_id
+            result.nodes.append(
+                GraphNode(
+                    id=model_id,
+                    kind=NodeKind.ENTITY,
+                    label=model_name,
+                    fqn=f"{ctx.file_path}::{model_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={"framework": "sequelize", "definition": "define"},
+                )
+            )
+
+        # Detect class X extends Model -> ENTITY
+        for match in self._EXTENDS_MODEL_RE.finditer(text):
+            class_name = match.group(1)
+            line = text[: match.start()].count("\n") + 1
+            if class_name not in seen_models:
+                model_id = f"sequelize:{ctx.file_path}:model:{class_name}"
+                seen_models[class_name] = model_id
+                result.nodes.append(
+                    GraphNode(
+                        id=model_id,
+                        kind=NodeKind.ENTITY,
+                        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": "sequelize", "definition": "class"},
+                    )
+                )
+
+        # Detect associations -> DEPENDS_ON edges
+        for match in self._ASSOCIATION_RE.finditer(text):
+            source_model = match.group(1)
+            assoc_type = match.group(2)
+            target_model = match.group(3)
+            line = text[: match.start()].count("\n") + 1
+
+            source_id = seen_models.get(
+                source_model, f"sequelize:{ctx.file_path}:model:{source_model}"
+            )
+            target_id = seen_models.get(
+                target_model, f"sequelize:{ctx.file_path}:model:{target_model}"
+            )
+            result.edges.append(
+                GraphEdge(
+                    source=source_id,
+                    target=target_id,
+                    kind=EdgeKind.DEPENDS_ON,
+                    label=assoc_type,
+                    properties={"association": assoc_type, "line": line},
+                )
+            )
+
+        # Detect query operations -> QUERIES edges
+        for match in self._QUERY_RE.finditer(text):
+            model_name = match.group(1)
+            operation = match.group(2)
+            line = text[: match.start()].count("\n") + 1
+
+            target_id = seen_models.get(
+                model_name, f"sequelize:{ctx.file_path}:model:{model_name}"
+            )
+            result.edges.append(
+                GraphEdge(
+                    source=ctx.file_path,
+                    target=target_id,
+                    kind=EdgeKind.QUERIES,
+                    label=f"{model_name}.{operation}",
+                    properties={"operation": operation, "line": line},
+                )
+            )
+
+        return result

osscodeiq/detectors/typescript/typeorm_entities.py

@@ -0,0 +1,86 @@
+"""TypeORM / Prisma entity detector for TypeScript."""
+
+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 TypeORMEntityDetector:
+    """Detects TypeORM entity definitions (@Entity decorator)."""
+
+    name: str = "typescript.typeorm_entities"
+    supported_languages: tuple[str, ...] = ("typescript",)
+
+    # @Entity('users') or @Entity() class User { ... }
+    _ENTITY_PATTERN = re.compile(
+        r"@Entity\(\s*['\"`]?(\w*)['\"`]?\s*\)\s*\n\s*(?:export\s+)?class\s+(\w+)"
+    )
+
+    # @Column() name: string;
+    _COLUMN_PATTERN = re.compile(
+        r"@Column\([^)]*\)\s*\n?\s*(\w+)\s*[!?]?\s*:\s*(\w+)"
+    )
+
+    # @ManyToOne, @OneToMany, @ManyToMany, @OneToOne
+    _RELATION_PATTERN = re.compile(
+        r"@(ManyToOne|OneToMany|ManyToMany|OneToOne)\(\s*\(\)\s*=>\s*(\w+)"
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        for match in self._ENTITY_PATTERN.finditer(text):
+            table_name = match.group(1) or match.group(2).lower() + "s"
+            class_name = match.group(2)
+            line = text[:match.start()].count("\n") + 1
+
+            # Find columns in class body (rough heuristic)
+            class_start = match.end()
+            brace_count = 0
+            class_end = len(text)
+            for i, ch in enumerate(text[class_start:], class_start):
+                if ch == "{":
+                    brace_count += 1
+                elif ch == "}":
+                    brace_count -= 1
+                    if brace_count == 0:
+                        class_end = i
+                        break
+            class_body = text[class_start:class_end]
+
+            columns = [m.group(1) for m in self._COLUMN_PATTERN.finditer(class_body)]
+
+            node_id = f"entity:{ctx.module_name or ''}:{class_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.ENTITY,
+                label=class_name,
+                fqn=f"{ctx.file_path}::{class_name}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                annotations=["@Entity"],
+                properties={
+                    "table_name": table_name,
+                    "columns": columns,
+                    "framework": "typeorm",
+                },
+            ))
+
+            # Detect relationships
+            for rel_match in self._RELATION_PATTERN.finditer(class_body):
+                rel_type = rel_match.group(1)
+                target_entity = rel_match.group(2)
+                target_id = f"entity:{ctx.module_name or ''}:{target_entity}"
+                result.edges.append(GraphEdge(
+                    source=node_id,
+                    target=target_id,
+                    kind=EdgeKind.MAPS_TO,
+                    label=rel_type,
+                ))
+
+        return result

osscodeiq/detectors/typescript/typescript_structures.py

@@ -0,0 +1,185 @@
+"""Regex-based TypeScript/JavaScript structures detector."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text, find_line_number
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_INTERFACE_RE = re.compile(r'^\s*(?:export\s+)?interface\s+(\w+)', re.MULTILINE)
+_TYPE_RE = re.compile(r'^\s*(?:export\s+)?type\s+(\w+)\s*=', re.MULTILINE)
+_CLASS_RE = re.compile(r'^\s*(?:export\s+)?(?:abstract\s+)?class\s+(\w+)', re.MULTILINE)
+_FUNC_RE = re.compile(
+    r'^\s*(?:export\s+)?(default\s+)?(?:(async)\s+)?function\s+(\w+)',
+    re.MULTILINE,
+)
+_CONST_FUNC_RE = re.compile(
+    r'^\s*(?:export\s+)?const\s+(\w+)\s*=\s*(?:(async)\s+)?\(',
+    re.MULTILINE,
+)
+_ENUM_RE = re.compile(r'^\s*(?:export\s+)?(?:const\s+)?enum\s+(\w+)', re.MULTILINE)
+_IMPORT_RE = re.compile(r'''import\s+.*?\s+from\s+['"]([^'"]+)['"]''', re.MULTILINE)
+_NAMESPACE_RE = re.compile(r'^\s*(?:export\s+)?namespace\s+(\w+)', re.MULTILINE)
+
+
+class TypeScriptStructuresDetector:
+    """Detects TypeScript/JavaScript interfaces, types, classes, functions, enums, imports, and namespaces."""
+
+    name: str = "typescript_structures"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript")
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        fp = ctx.file_path
+        file_node_id = fp
+
+        # Interfaces
+        for m in _INTERFACE_RE.finditer(text):
+            iface_name = m.group(1)
+            node_id = f"ts:{fp}:interface:{iface_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.INTERFACE,
+                label=iface_name,
+                fqn=iface_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=fp,
+                    line_start=find_line_number(text, m.start()),
+                ),
+            ))
+
+        # Type aliases
+        for m in _TYPE_RE.finditer(text):
+            type_name = m.group(1)
+            node_id = f"ts:{fp}:type:{type_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.CLASS,
+                label=type_name,
+                fqn=type_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=fp,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties={"type_alias": True},
+            ))
+
+        # Classes
+        for m in _CLASS_RE.finditer(text):
+            class_name = m.group(1)
+            node_id = f"ts:{fp}:class:{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=fp,
+                    line_start=find_line_number(text, m.start()),
+                ),
+            ))
+
+        # Named functions (export [default] [async] function name)
+        for m in _FUNC_RE.finditer(text):
+            is_default = m.group(1) is not None
+            is_async = m.group(2) is not None
+            func_name = m.group(3)
+            node_id = f"ts:{fp}:func:{func_name}"
+            properties: dict = {}
+            if is_default:
+                properties["default"] = True
+            if is_async:
+                properties["async"] = True
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.METHOD,
+                label=func_name,
+                fqn=func_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=fp,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties=properties,
+            ))
+
+        # Arrow / const functions (export const name = [async] ()
+        for m in _CONST_FUNC_RE.finditer(text):
+            func_name = m.group(1)
+            is_async = m.group(2) is not None
+            node_id = f"ts:{fp}:func:{func_name}"
+            # Avoid duplicate if a named function already captured this id
+            existing_ids = {n.id for n in result.nodes}
+            if node_id in existing_ids:
+                continue
+            properties = {}
+            if is_async:
+                properties["async"] = True
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.METHOD,
+                label=func_name,
+                fqn=func_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=fp,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties=properties,
+            ))
+
+        # Enums
+        for m in _ENUM_RE.finditer(text):
+            enum_name = m.group(1)
+            node_id = f"ts:{fp}:enum:{enum_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.ENUM,
+                label=enum_name,
+                fqn=enum_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=fp,
+                    line_start=find_line_number(text, m.start()),
+                ),
+            ))
+
+        # Imports
+        for m in _IMPORT_RE.finditer(text):
+            module_path = m.group(1)
+            result.edges.append(GraphEdge(
+                source=file_node_id,
+                target=module_path,
+                kind=EdgeKind.IMPORTS,
+                label=f"{fp} imports {module_path}",
+            ))
+
+        # Namespaces
+        for m in _NAMESPACE_RE.finditer(text):
+            ns_name = m.group(1)
+            node_id = f"ts:{fp}:namespace:{ns_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.MODULE,
+                label=ns_name,
+                fqn=ns_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=fp,
+                    line_start=find_line_number(text, m.start()),
+                ),
+            ))
+
+        return result

osscodeiq/detectors/utils.py

@@ -0,0 +1,49 @@
+"""Shared utilities for OSSCodeIQ detectors."""
+
+from __future__ import annotations
+
+from typing import Iterator
+
+from osscodeiq.detectors.base import DetectorContext
+
+
+def decode_text(ctx: DetectorContext) -> str:
+    """Decode raw bytes to text, handling encoding errors gracefully."""
+    return ctx.content.decode("utf-8", errors="replace")
+
+
+def iter_lines(ctx: DetectorContext) -> Iterator[tuple[int, str]]:
+    """Yield (line_number, line_text) tuples from detector context.
+
+    Line numbers are 1-based (matching source file conventions).
+    """
+    text = decode_text(ctx)
+    for i, line in enumerate(text.split("\n")):
+        yield i + 1, line
+
+
+def find_line_number(text: str, byte_offset: int) -> int:
+    """Find the 1-based line number for a byte offset in text."""
+    return text[:byte_offset].count("\n") + 1
+
+
+def filename(ctx: DetectorContext) -> str:
+    """Extract the filename (without path) from the detector context."""
+    return ctx.file_path.rsplit("/", 1)[-1] if "/" in ctx.file_path else ctx.file_path
+
+
+def matches_filename(ctx: DetectorContext, *patterns: str) -> bool:
+    """Check if the file matches any of the given filename patterns.
+
+    Supports exact match and prefix+suffix matching.
+    Examples: matches_filename(ctx, "package.json", "tsconfig.*.json")
+    """
+    name = filename(ctx)
+    for pattern in patterns:
+        if "*" in pattern:
+            prefix, suffix = pattern.split("*", 1)
+            if name.startswith(prefix) and name.endswith(suffix):
+                return True
+        elif name == pattern:
+            return True
+    return False

osscodeiq/discovery/__init__.py

@@ -0,0 +1,11 @@
+from osscodeiq.discovery.file_discovery import (
+    ChangeType,
+    DiscoveredFile,
+    FileDiscovery,
+)
+
+__all__ = [
+    "ChangeType",
+    "DiscoveredFile",
+    "FileDiscovery",
+]