osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/shell/powershell_detector.py

@@ -0,0 +1,118 @@
+"""PowerShell script detector for functions, modules, parameters, and dot-sourcing."""
+
+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,
+)
+
+_FUNC_RE = re.compile(r'function\s+([\w-]+)\s*(?:\([^)]*\))?\s*\{', re.IGNORECASE)
+_IMPORT_RE = re.compile(r'Import-Module\s+(\S+)', re.IGNORECASE)
+_DOT_SOURCE_RE = re.compile(r'\.\s+["\']?(\S+\.ps(?:1|m1))["\']?')
+_PARAM_RE = re.compile(r'\[Parameter[^]]*\]\s*\[(\w+)\]\s*\$(\w+)')
+_CMDLET_BINDING_RE = re.compile(r'\[CmdletBinding\(\)\]', re.IGNORECASE)
+
+
+class PowerShellDetector:
+    """Detects PowerShell script structures: functions, modules, parameters, and dot-sourcing."""
+
+    name: str = "powershell"
+    supported_languages: tuple[str, ...] = ("powershell",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        # Track which functions have CmdletBinding for advanced function marking
+        # We do a two-pass approach: first find functions, then check for CmdletBinding nearby
+        func_positions: list[tuple[int, str]] = []
+
+        # Detect function definitions
+        for i, line in enumerate(lines):
+            m = _FUNC_RE.search(line)
+            if not m:
+                continue
+            func_name = m.group(1)
+            func_positions.append((i, func_name))
+
+            # Check if [CmdletBinding()] appears within the next few lines
+            is_advanced = False
+            for j in range(i + 1, min(i + 5, len(lines))):
+                if _CMDLET_BINDING_RE.search(lines[j]):
+                    is_advanced = True
+                    break
+
+            props: dict = {}
+            if is_advanced:
+                props["advanced_function"] = True
+
+            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=i + 1,
+                ),
+                properties=props,
+            ))
+
+        # Detect Import-Module statements
+        for i, line in enumerate(lines):
+            m = _IMPORT_RE.search(line)
+            if not m:
+                continue
+            module_name = m.group(1)
+            result.edges.append(GraphEdge(
+                source=ctx.file_path,
+                target=module_name,
+                kind=EdgeKind.IMPORTS,
+                label=f"{ctx.file_path} imports module {module_name}",
+            ))
+
+        # Detect dot-sourcing
+        for i, line in enumerate(lines):
+            m = _DOT_SOURCE_RE.search(line)
+            if not m:
+                continue
+            sourced_file = m.group(1)
+            result.edges.append(GraphEdge(
+                source=ctx.file_path,
+                target=sourced_file,
+                kind=EdgeKind.IMPORTS,
+                label=f"{ctx.file_path} dot-sources {sourced_file}",
+            ))
+
+        # Detect typed parameters with [Parameter] attribute
+        for i, line in enumerate(lines):
+            m = _PARAM_RE.search(line)
+            if not m:
+                continue
+            param_type = m.group(1)
+            param_name = m.group(2)
+
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:param:{param_name}",
+                kind=NodeKind.CONFIG_DEFINITION,
+                label=f"${param_name}: {param_type}",
+                fqn=param_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=i + 1,
+                ),
+                properties={"param_type": param_type},
+            ))
+
+        return result

osscodeiq/detectors/typescript/express_routes.py

@@ -0,0 +1,55 @@
+"""Express.js 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 EdgeKind, GraphEdge, GraphNode, NodeKind, SourceLocation
+
+
+class ExpressRouteDetector:
+    """Detects Express.js route definitions (app.get, router.post, etc.)."""
+
+    name: str = "typescript.express_routes"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript")
+
+    # app.get('/path', handler) or router.post('/path', middleware, handler)
+    _ROUTE_PATTERN = re.compile(
+        r"(\w+)\.(get|post|put|delete|patch|options|head|all)\(\s*['\"`]([^'\"`]+)['\"`]"
+    )
+
+    # Router prefix: app.use('/api/v1', router) or app.use('/users', userRouter)
+    _USE_PATTERN = re.compile(
+        r"(\w+)\.use\(\s*['\"`]([^'\"`]+)['\"`]\s*,\s*(\w+)"
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        for match in self._ROUTE_PATTERN.finditer(text):
+            router_name = match.group(1)
+            method = match.group(2).upper()
+            path = match.group(3)
+            line = text[:match.start()].count("\n") + 1
+
+            node_id = f"endpoint:{ctx.module_name or ''}:{method}:{path}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.ENDPOINT,
+                label=f"{method} {path}",
+                fqn=f"{ctx.file_path}::{method}:{path}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                properties={
+                    "protocol": "REST",
+                    "http_method": method,
+                    "path_pattern": path,
+                    "framework": "express",
+                    "router": router_name,
+                },
+            ))
+
+        return result

osscodeiq/detectors/typescript/fastify_routes.py

@@ -0,0 +1,156 @@
+"""Fastify 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 EdgeKind, GraphEdge, GraphNode, NodeKind, SourceLocation
+
+
+class FastifyRouteDetector:
+    """Detects Fastify route definitions, plugins, and hooks."""
+
+    name: str = "fastify_routes"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript")
+
+    # fastify.get('/path', handler) or fastify.post('/path', opts, handler)
+    _SHORTHAND_PATTERN = re.compile(
+        r"(\w+)\.(get|post|put|delete|patch)\(\s*['\"`]([^'\"`]+)['\"`]"
+    )
+
+    # fastify.route({ method: 'GET', url: '/path' })
+    _ROUTE_PATTERN = re.compile(
+        r"(\w+)\.route\(\s*\{[\s\S]*?"
+        r"method\s*:\s*['\"`](\w+)['\"`]"
+        r"[\s\S]*?"
+        r"url\s*:\s*['\"`]([^'\"`]+)['\"`]",
+    )
+
+    # fastify.register(plugin) or fastify.register(import('./plugin'))
+    _REGISTER_PATTERN = re.compile(
+        r"(\w+)\.register\(\s*(\w+|import\([^)]+\))"
+    )
+
+    # fastify.addHook('onRequest', handler)
+    _HOOK_PATTERN = re.compile(
+        r"(\w+)\.addHook\(\s*['\"`](\w+)['\"`]"
+    )
+
+    # schema: { body: SomeType } inside route options
+    _SCHEMA_PATTERN = re.compile(
+        r"schema\s*:\s*\{([^}]+)\}"
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Detect shorthand routes: fastify.get(), .post(), etc.
+        for match in self._SHORTHAND_PATTERN.finditer(text):
+            method = match.group(2).upper()
+            path = match.group(3)
+            line = text[: match.start()].count("\n") + 1
+
+            node_id = f"fastify:{ctx.file_path}:{method}:{path}:{line}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.ENDPOINT,
+                    label=f"{method} {path}",
+                    fqn=f"{ctx.file_path}::{method}:{path}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "protocol": "REST",
+                        "http_method": method,
+                        "path_pattern": path,
+                        "framework": "fastify",
+                    },
+                )
+            )
+
+        # Detect fastify.route({ method, url })
+        for match in self._ROUTE_PATTERN.finditer(text):
+            method = match.group(2).upper()
+            path = match.group(3)
+            line = text[: match.start()].count("\n") + 1
+
+            node_id = f"fastify:{ctx.file_path}:{method}:{path}:{line}"
+            # Avoid duplicates from shorthand detection
+            if any(n.id == node_id for n in result.nodes):
+                continue
+
+            # Check for schema in the route call block (search forward from match start
+            # until we find the closing ");")
+            route_start = match.start()
+            route_block = text[route_start:text.find(");", route_start) + 2]
+            schema_props = {}
+            schema_match = self._SCHEMA_PATTERN.search(route_block)
+            if schema_match:
+                schema_props["schema"] = schema_match.group(1).strip()
+
+            props = {
+                "protocol": "REST",
+                "http_method": method,
+                "path_pattern": path,
+                "framework": "fastify",
+            }
+            props.update(schema_props)
+
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.ENDPOINT,
+                    label=f"{method} {path}",
+                    fqn=f"{ctx.file_path}::{method}:{path}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties=props,
+                )
+            )
+
+        # Detect fastify.register(plugin)
+        for match in self._REGISTER_PATTERN.finditer(text):
+            plugin_ref = match.group(2)
+            line = text[: match.start()].count("\n") + 1
+
+            edge_id_source = f"fastify:{ctx.file_path}:server:{line}"
+            edge_id_target = f"fastify:{ctx.file_path}:plugin:{plugin_ref}:{line}"
+
+            result.edges.append(
+                GraphEdge(
+                    source=edge_id_source,
+                    target=edge_id_target,
+                    kind=EdgeKind.IMPORTS,
+                    label=f"register {plugin_ref}",
+                    properties={
+                        "framework": "fastify",
+                        "plugin": plugin_ref,
+                    },
+                )
+            )
+
+        # Detect fastify.addHook('hookName', handler)
+        for match in self._HOOK_PATTERN.finditer(text):
+            hook_name = match.group(2)
+            line = text[: match.start()].count("\n") + 1
+
+            node_id = f"fastify:{ctx.file_path}:hook:{hook_name}:{line}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.MIDDLEWARE,
+                    label=f"hook:{hook_name}",
+                    fqn=f"{ctx.file_path}::hook:{hook_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "framework": "fastify",
+                        "hook_name": hook_name,
+                    },
+                )
+            )
+
+        return result

osscodeiq/detectors/typescript/graphql_resolvers.py

@@ -0,0 +1,100 @@
+"""GraphQL resolver 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 GraphQLResolverDetector:
+    """Detects GraphQL resolvers and type definitions in TypeScript/JavaScript."""
+
+    name: str = "typescript.graphql_resolvers"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript")
+
+    # NestJS GraphQL: @Query(), @Mutation(), @Resolver()
+    _NESTJS_RESOLVER = re.compile(
+        r"@Resolver\(\s*(?:of\s*=>\s*)?(\w+)?\s*\)\s*\n\s*(?:export\s+)?class\s+(\w+)"
+    )
+    _NESTJS_QUERY = re.compile(
+        r"@(Query|Mutation|Subscription)\(.*?\)\s*\n\s*(?:async\s+)?(\w+)"
+    )
+
+    # Apollo/generic: type Query { ... } or typeDefs with gql template
+    _TYPEDEF_PATTERN = re.compile(
+        r"type\s+(Query|Mutation|Subscription)\s*\{([^}]+)\}"
+    )
+
+    # resolvers object: Query: { users: ... }
+    _RESOLVER_FIELD = re.compile(
+        r"(Query|Mutation|Subscription)\s*:\s*\{([^}]+)\}"
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # NestJS-style resolvers
+        for match in self._NESTJS_RESOLVER.finditer(text):
+            entity_type = match.group(1)
+            class_name = match.group(2)
+            line = text[:match.start()].count("\n") + 1
+
+            class_id = f"class:{ctx.file_path}::{class_name}"
+            result.nodes.append(GraphNode(
+                id=class_id,
+                kind=NodeKind.CLASS,
+                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=["@Resolver"],
+                properties={"framework": "nestjs-graphql", "entity_type": entity_type},
+            ))
+
+        for match in self._NESTJS_QUERY.finditer(text):
+            op_type = match.group(1)
+            func_name = match.group(2)
+            line = text[:match.start()].count("\n") + 1
+
+            node_id = f"endpoint:{ctx.module_name or ''}:graphql:{op_type}:{func_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.ENDPOINT,
+                label=f"GraphQL {op_type}: {func_name}",
+                fqn=f"{ctx.file_path}::{func_name}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                properties={
+                    "protocol": "GraphQL",
+                    "operation_type": op_type.lower(),
+                    "field_name": func_name,
+                },
+            ))
+
+        # Schema-defined resolvers
+        for match in self._TYPEDEF_PATTERN.finditer(text):
+            op_type = match.group(1)
+            fields_block = match.group(2)
+            base_line = text[:match.start()].count("\n") + 1
+
+            for field_match in re.finditer(r"(\w+)\s*(?:\([^)]*\))?\s*:", fields_block):
+                field_name = field_match.group(1)
+                node_id = f"endpoint:{ctx.module_name or ''}:graphql:{op_type}:{field_name}"
+                result.nodes.append(GraphNode(
+                    id=node_id,
+                    kind=NodeKind.ENDPOINT,
+                    label=f"GraphQL {op_type}: {field_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=base_line),
+                    properties={
+                        "protocol": "GraphQL",
+                        "operation_type": op_type.lower(),
+                        "field_name": field_name,
+                    },
+                ))
+
+        return result

osscodeiq/detectors/typescript/kafka_js.py

@@ -0,0 +1,164 @@
+"""KafkaJS detector for TypeScript/JavaScript source files.
+
+Detects usage of the KafkaJS library in Node.js applications.
+"""
+
+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,
+)
+
+# Connection pattern: new Kafka({
+_KAFKA_NEW_RE = re.compile(r"new\s+Kafka\s*\(\s*\{", re.MULTILINE)
+
+# Producer pattern: kafka.producer()
+_PRODUCER_RE = re.compile(r"\.producer\s*\(\s*\)", re.MULTILINE)
+
+# Producer send: producer.send({ topic: 'name' })
+_PRODUCER_SEND_RE = re.compile(
+    r"\.send\s*\(\s*\{\s*topic\s*:\s*['\"]([^'\"]+)['\"]", re.MULTILINE
+)
+
+# Consumer pattern: kafka.consumer({ groupId: 'group' })
+_CONSUMER_RE = re.compile(
+    r"\.consumer\s*\(\s*\{\s*groupId\s*:\s*['\"]([^'\"]+)['\"]", re.MULTILINE
+)
+
+# Consumer subscribe: consumer.subscribe({ topic: 'name' })
+_SUBSCRIBE_RE = re.compile(
+    r"\.subscribe\s*\(\s*\{\s*topic\s*:\s*['\"]([^'\"]+)['\"]", re.MULTILINE
+)
+
+# Consumer run: consumer.run({ eachMessage:
+_RUN_EACH_RE = re.compile(
+    r"\.run\s*\(\s*\{\s*eachMessage\s*:", re.MULTILINE
+)
+
+
+class KafkaJSDetector:
+    """Detects KafkaJS usage in TypeScript/JavaScript applications."""
+
+    name: str = "kafka_js"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript")
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+        fp = ctx.file_path
+
+        # Quick bail-out
+        if "Kafka" not in text and "kafka" not in text:
+            return result
+
+        seen_topics: set[str] = set()
+        file_node_id = f"kafka_js:{fp}"
+
+        def _ensure_topic(topic: str, line: int) -> str:
+            topic_id = f"kafka_js:{fp}:topic:{topic}"
+            if topic not in seen_topics:
+                seen_topics.add(topic)
+                result.nodes.append(GraphNode(
+                    id=topic_id,
+                    kind=NodeKind.TOPIC,
+                    label=f"kafka:{topic}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp, line_start=line),
+                    properties={"broker": "kafka", "topic": topic},
+                ))
+            return topic_id
+
+        # Detect new Kafka({ -> DATABASE_CONNECTION node
+        for i, line in enumerate(lines):
+            lineno = i + 1
+            if _KAFKA_NEW_RE.search(line):
+                result.nodes.append(GraphNode(
+                    id=f"kafka_js:{fp}:connection:{lineno}",
+                    kind=NodeKind.DATABASE_CONNECTION,
+                    label="KafkaJS connection",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp, line_start=lineno),
+                    properties={"broker": "kafka", "library": "kafkajs"},
+                ))
+
+        # Detect kafka.producer() -> properties on file node
+        for i, line in enumerate(lines):
+            lineno = i + 1
+            if _PRODUCER_RE.search(line):
+                result.nodes.append(GraphNode(
+                    id=f"kafka_js:{fp}:producer:{lineno}",
+                    kind=NodeKind.TOPIC,
+                    label="kafka:producer",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp, line_start=lineno),
+                    properties={"role": "producer"},
+                ))
+
+        # Detect producer.send({ topic: 'name' }) -> TOPIC + PRODUCES edge
+        for i, line in enumerate(lines):
+            lineno = i + 1
+            m = _PRODUCER_SEND_RE.search(line)
+            if m:
+                topic = m.group(1)
+                topic_id = _ensure_topic(topic, lineno)
+                result.edges.append(GraphEdge(
+                    source=file_node_id,
+                    target=topic_id,
+                    kind=EdgeKind.PRODUCES,
+                    label=f"produces to {topic}",
+                    properties={"topic": topic},
+                ))
+
+        # Detect kafka.consumer({ groupId: 'group' }) -> properties
+        for i, line in enumerate(lines):
+            lineno = i + 1
+            m = _CONSUMER_RE.search(line)
+            if m:
+                group_id = m.group(1)
+                result.nodes.append(GraphNode(
+                    id=f"kafka_js:{fp}:consumer:{lineno}",
+                    kind=NodeKind.TOPIC,
+                    label=f"kafka:consumer:{group_id}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp, line_start=lineno),
+                    properties={"role": "consumer", "group_id": group_id},
+                ))
+
+        # Detect consumer.subscribe({ topic: 'name' }) -> TOPIC + CONSUMES edge
+        for i, line in enumerate(lines):
+            lineno = i + 1
+            m = _SUBSCRIBE_RE.search(line)
+            if m:
+                topic = m.group(1)
+                topic_id = _ensure_topic(topic, lineno)
+                result.edges.append(GraphEdge(
+                    source=file_node_id,
+                    target=topic_id,
+                    kind=EdgeKind.CONSUMES,
+                    label=f"consumes from {topic}",
+                    properties={"topic": topic},
+                ))
+
+        # Detect consumer.run({ eachMessage: }) -> EVENT node
+        for i, line in enumerate(lines):
+            lineno = i + 1
+            if _RUN_EACH_RE.search(line):
+                result.nodes.append(GraphNode(
+                    id=f"kafka_js:{fp}:event:{lineno}",
+                    kind=NodeKind.EVENT,
+                    label="kafka:eachMessage",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp, line_start=lineno),
+                    properties={"handler": "eachMessage"},
+                ))
+
+        return result