osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/output/dot.py

@@ -0,0 +1,171 @@
+"""Graphviz DOT renderer for the OSSCodeIQ graph."""
+
+from __future__ import annotations
+
+import re
+from typing import Literal
+
+from osscodeiq.graph.store import GraphStore
+from osscodeiq.models.graph import EdgeKind, GraphEdge, GraphNode, NodeKind
+
+
+def _sanitize_id(raw: str) -> str:
+    """Replace characters invalid in DOT identifiers."""
+    return re.sub(r"[^a-zA-Z0-9_]", "_", raw)
+
+
+def _quote(text: str) -> str:
+    """Escape a string for use inside DOT double-quotes."""
+    return text.replace("\\", "\\\\").replace('"', '\\"')
+
+
+# -- Node shape and colour mapping -----------------------------------------
+
+_NODE_STYLES: dict[NodeKind, dict[str, str]] = {
+    NodeKind.MODULE:             {"shape": "box3d",       "fillcolor": "#4A90D9", "fontcolor": "white"},
+    NodeKind.PACKAGE:            {"shape": "box3d",       "fillcolor": "#4A90D9", "fontcolor": "white"},
+    NodeKind.CLASS:              {"shape": "box",         "fillcolor": "#A8D8EA", "fontcolor": "black"},
+    NodeKind.METHOD:             {"shape": "box",         "fillcolor": "#D4E6F1", "fontcolor": "black"},
+    NodeKind.ENDPOINT:           {"shape": "hexagon",     "fillcolor": "#F9E79F", "fontcolor": "black"},
+    NodeKind.ENTITY:             {"shape": "cylinder",    "fillcolor": "#ABEBC6", "fontcolor": "black"},
+    NodeKind.REPOSITORY:         {"shape": "cylinder",    "fillcolor": "#ABEBC6", "fontcolor": "black"},
+    NodeKind.QUERY:              {"shape": "box",         "fillcolor": "#D5F5E3", "fontcolor": "black"},
+    NodeKind.MIGRATION:          {"shape": "box",         "fillcolor": "#D5F5E3", "fontcolor": "black"},
+    NodeKind.TOPIC:              {"shape": "parallelogram", "fillcolor": "#F5B7B1", "fontcolor": "black"},
+    NodeKind.QUEUE:              {"shape": "parallelogram", "fillcolor": "#F5B7B1", "fontcolor": "black"},
+    NodeKind.EVENT:              {"shape": "parallelogram", "fillcolor": "#F5B7B1", "fontcolor": "black"},
+    NodeKind.RMI_INTERFACE:      {"shape": "component",  "fillcolor": "#D7BDE2", "fontcolor": "black"},
+    NodeKind.CONFIG_FILE:        {"shape": "note",        "fillcolor": "#FDEBD0", "fontcolor": "black"},
+    NodeKind.CONFIG_KEY:         {"shape": "note",        "fillcolor": "#FDEBD0", "fontcolor": "black"},
+    NodeKind.WEBSOCKET_ENDPOINT: {"shape": "hexagon",     "fillcolor": "#F9E79F", "fontcolor": "black"},
+}
+
+# -- Edge styles -----------------------------------------------------------
+
+_EDGE_STYLES: dict[EdgeKind, dict[str, str]] = {
+    EdgeKind.CALLS:       {"style": "solid",  "arrowhead": "normal"},
+    EdgeKind.DEPENDS_ON:  {"style": "solid",  "arrowhead": "normal"},
+    EdgeKind.IMPORTS:     {"style": "solid",  "arrowhead": "normal"},
+    EdgeKind.INJECTS:     {"style": "solid",  "arrowhead": "normal"},
+    EdgeKind.QUERIES:     {"style": "solid",  "arrowhead": "normal"},
+    EdgeKind.MAPS_TO:     {"style": "solid",  "arrowhead": "normal"},
+    EdgeKind.READS_CONFIG: {"style": "solid", "arrowhead": "normal"},
+    EdgeKind.MIGRATES:    {"style": "solid",  "arrowhead": "normal"},
+    EdgeKind.CONTAINS:    {"style": "solid",  "arrowhead": "normal"},
+    EdgeKind.EXPOSES:     {"style": "solid",  "arrowhead": "normal"},
+    EdgeKind.PRODUCES:    {"style": "dashed", "arrowhead": "normal"},
+    EdgeKind.CONSUMES:    {"style": "dashed", "arrowhead": "normal"},
+    EdgeKind.PUBLISHES:   {"style": "dashed", "arrowhead": "normal"},
+    EdgeKind.LISTENS:     {"style": "dashed", "arrowhead": "normal"},
+    EdgeKind.INVOKES_RMI: {"style": "dashed", "arrowhead": "normal"},
+    EdgeKind.EXPORTS_RMI: {"style": "dashed", "arrowhead": "normal"},
+    EdgeKind.EXTENDS:     {"style": "solid",  "arrowhead": "empty"},
+    EdgeKind.IMPLEMENTS:  {"style": "solid",  "arrowhead": "empty"},
+}
+
+
+ClusterBy = Literal["module", "domain", "node-type", None]
+
+
+class DotRenderer:
+    """Render a :class:`GraphStore` as a Graphviz DOT graph."""
+
+    def __init__(
+        self,
+        rankdir: str = "LR",
+        cluster_by: ClusterBy = None,
+        fontname: str = "Helvetica",
+        fontsize: str = "11",
+    ) -> None:
+        self._rankdir = rankdir
+        self._cluster_by = cluster_by
+        self._fontname = fontname
+        self._fontsize = fontsize
+
+    # -- public API -------------------------------------------------
+
+    def render(self, store: GraphStore, cluster_by: ClusterBy | None = None) -> str:
+        """Return a DOT-language string."""
+        lines: list[str] = [
+            "digraph CodeIntelligence {",
+            f'    rankdir={self._rankdir};',
+            f'    fontname="{self._fontname}";',
+            f'    fontsize={self._fontsize};',
+            f'    node [fontname="{self._fontname}", fontsize={self._fontsize}, style=filled];',
+            f'    edge [fontname="{self._fontname}", fontsize={self._fontsize}];',
+            "",
+        ]
+
+        nodes = store.all_nodes()
+        edges = store.all_edges()
+
+        if self._cluster_by:
+            lines.extend(self._render_clustered(nodes))
+        else:
+            for node in nodes:
+                lines.append(self._node_def(node))
+            lines.append("")
+
+        for edge in edges:
+            lines.append(self._edge_def(edge))
+
+        lines.append("}")
+        return "\n".join(lines) + "\n"
+
+    # -- internal ---------------------------------------------------
+
+    def _node_def(self, node: GraphNode) -> str:
+        sid = _sanitize_id(node.id)
+        style = _NODE_STYLES.get(node.kind, {"shape": "box", "fillcolor": "#FFFFFF", "fontcolor": "black"})
+        label = _quote(node.label)
+        attrs = (
+            f'label="{label}", '
+            f'shape={style["shape"]}, '
+            f'fillcolor="{style["fillcolor"]}", '
+            f'fontcolor="{style["fontcolor"]}"'
+        )
+        return f"    {sid} [{attrs}];"
+
+    def _edge_def(self, edge: GraphEdge) -> str:
+        src = _sanitize_id(edge.source)
+        tgt = _sanitize_id(edge.target)
+        style = _EDGE_STYLES.get(
+            edge.kind,
+            {"style": "solid", "arrowhead": "normal"},
+        )
+        label = _quote(edge.label or edge.kind.value)
+        attrs = (
+            f'label="{label}", '
+            f'style={style["style"]}, '
+            f'arrowhead={style["arrowhead"]}'
+        )
+        return f"    {src} -> {tgt} [{attrs}];"
+
+    def _cluster_key(self, node: GraphNode) -> str:
+        if self._cluster_by == "module":
+            return node.module or "unknown"
+        if self._cluster_by == "domain":
+            return node.properties.get("domain", node.module or "unknown")  # type: ignore[return-value]
+        if self._cluster_by == "node-type":
+            return node.kind.value
+        return "default"
+
+    def _render_clustered(self, nodes: list[GraphNode]) -> list[str]:
+        clusters: dict[str, list[GraphNode]] = {}
+        for node in nodes:
+            key = self._cluster_key(node)
+            clusters.setdefault(key, []).append(node)
+
+        lines: list[str] = []
+        for idx, (cluster_name, cluster_nodes) in enumerate(sorted(clusters.items())):
+            sub_id = _sanitize_id(f"cluster_{cluster_name}")
+            lines.append(f"    subgraph {sub_id} {{")
+            lines.append(f'        label="{_quote(cluster_name)}";')
+            lines.append('        style=filled;')
+            lines.append('        color="#E8E8E8";')
+            for node in cluster_nodes:
+                lines.append(f"    {self._node_def(node)}")
+            lines.append("    }")
+            lines.append("")
+
+        return lines

osscodeiq/output/mermaid.py

@@ -0,0 +1,160 @@
+"""Mermaid diagram renderer for the OSSCodeIQ graph."""
+
+from __future__ import annotations
+
+import re
+from typing import Literal
+
+from osscodeiq.graph.store import GraphStore
+from osscodeiq.models.graph import EdgeKind, GraphEdge, GraphNode, NodeKind
+
+
+def _sanitize_id(raw: str) -> str:
+    """Replace characters that are invalid in Mermaid node IDs."""
+    return re.sub(r"[^a-zA-Z0-9_]", "_", raw)
+
+
+def _escape_label(text: str) -> str:
+    """Escape Mermaid special characters in labels."""
+    for ch in ('"', '|', '[', ']', '{', '}', '(', ')', '<', '>', '#'):
+        text = text.replace(ch, f"&#{ord(ch)};")
+    return text
+
+
+# -- Node shape templates --------------------------------------------------
+# Mermaid syntax: id[label], id([label]), id{{label}}, id[(label)], etc.
+
+_NODE_SHAPES: dict[NodeKind, tuple[str, str]] = {
+    NodeKind.MODULE:             ("[",  "]"),       # rectangle
+    NodeKind.PACKAGE:            ("[",  "]"),
+    NodeKind.CLASS:              ("[",  "]"),
+    NodeKind.METHOD:             ("([", "])"),       # stadium / pill
+    NodeKind.ENDPOINT:           ("{{", "}}"),       # hexagon
+    NodeKind.ENTITY:             ("[(", ")]"),       # cylinder
+    NodeKind.REPOSITORY:         ("[(", ")]"),
+    NodeKind.QUERY:              ("([", "])"),
+    NodeKind.MIGRATION:          ("([", "])"),
+    NodeKind.TOPIC:              ("[/", "/]"),       # parallelogram
+    NodeKind.QUEUE:              ("[/", "/]"),
+    NodeKind.EVENT:              ("[/", "/]"),
+    NodeKind.RMI_INTERFACE:      ("[[", "]]"),      # subroutine
+    NodeKind.CONFIG_FILE:        ("([", "])"),
+    NodeKind.CONFIG_KEY:         ("([", "])"),
+    NodeKind.WEBSOCKET_ENDPOINT: ("{{", "}}"),
+}
+
+# -- Edge arrow styles ------------------------------------------------------
+
+_EDGE_STYLES: dict[EdgeKind, str] = {
+    # Solid arrow  -->
+    EdgeKind.CALLS:       "-->",
+    EdgeKind.DEPENDS_ON:  "-->",
+    EdgeKind.IMPORTS:     "-->",
+    EdgeKind.INJECTS:     "-->",
+    EdgeKind.QUERIES:     "-->",
+    EdgeKind.MAPS_TO:     "-->",
+    EdgeKind.READS_CONFIG: "-->",
+    EdgeKind.MIGRATES:    "-->",
+    EdgeKind.CONTAINS:    "-->",
+    EdgeKind.EXPOSES:     "-->",
+    # Dotted arrow  -.->
+    EdgeKind.PRODUCES:    "-.->",
+    EdgeKind.CONSUMES:    "-.->",
+    EdgeKind.PUBLISHES:   "-.->",
+    EdgeKind.LISTENS:     "-.->",
+    EdgeKind.INVOKES_RMI: "-.->",
+    EdgeKind.EXPORTS_RMI: "-.->",
+    # Open arrowhead  --o
+    EdgeKind.EXTENDS:     "--o",
+    EdgeKind.IMPLEMENTS:  "--o",
+}
+
+
+ClusterBy = Literal["module", "domain", "node-type", None]
+
+
+class MermaidRenderer:
+    """Render a :class:`GraphStore` as a Mermaid flowchart."""
+
+    def __init__(
+        self,
+        direction: str = "LR",
+        cluster_by: ClusterBy = None,
+    ) -> None:
+        self._direction = direction
+        self._cluster_by = cluster_by
+
+    # -- public API -------------------------------------------------
+
+    def render(self, store: GraphStore, cluster_by: ClusterBy | None = None) -> str:
+        """Return a Mermaid flowchart string."""
+        effective_cluster = cluster_by or self._cluster_by
+        lines: list[str] = [f"graph {self._direction}"]
+
+        nodes = store.all_nodes()
+        edges = store.all_edges()
+
+        if effective_cluster:
+            old = self._cluster_by
+            self._cluster_by = effective_cluster
+            lines.extend(self._render_clustered(nodes, edges))
+            self._cluster_by = old
+        else:
+            lines.extend(self._render_flat(nodes, edges))
+
+        return "\n".join(lines) + "\n"
+
+    # -- internal ---------------------------------------------------
+
+    def _node_def(self, node: GraphNode) -> str:
+        sid = _sanitize_id(node.id)
+        left, right = _NODE_SHAPES.get(node.kind, ("[", "]"))
+        label = _escape_label(node.label)
+        return f"    {sid}{left}\"{label}\"{right}"
+
+    def _edge_def(self, edge: GraphEdge) -> str:
+        src = _sanitize_id(edge.source)
+        tgt = _sanitize_id(edge.target)
+        arrow = _EDGE_STYLES.get(edge.kind, "-->")
+        label = _escape_label(edge.label or edge.kind.value)
+        return f"    {src} {arrow}|{label}| {tgt}"
+
+    def _cluster_key(self, node: GraphNode) -> str:
+        if self._cluster_by == "module":
+            return node.module or "unknown"
+        if self._cluster_by == "domain":
+            return node.properties.get("domain", node.module or "unknown")  # type: ignore[return-value]
+        if self._cluster_by == "node-type":
+            return node.kind.value
+        return "default"
+
+    def _render_flat(
+        self, nodes: list[GraphNode], edges: list[GraphEdge]
+    ) -> list[str]:
+        lines: list[str] = []
+        for node in nodes:
+            lines.append(self._node_def(node))
+        for edge in edges:
+            lines.append(self._edge_def(edge))
+        return lines
+
+    def _render_clustered(
+        self, nodes: list[GraphNode], edges: list[GraphEdge]
+    ) -> list[str]:
+        clusters: dict[str, list[GraphNode]] = {}
+        for node in nodes:
+            key = self._cluster_key(node)
+            clusters.setdefault(key, []).append(node)
+
+        lines: list[str] = []
+        for idx, (cluster_name, cluster_nodes) in enumerate(sorted(clusters.items())):
+            sub_id = _sanitize_id(f"cluster_{cluster_name}")
+            lines.append(f"    subgraph {sub_id}[\"{cluster_name}\"]")
+            for node in cluster_nodes:
+                lines.append(f"    {self._node_def(node)}")
+            lines.append("    end")
+
+        for edge in edges:
+            lines.append(self._edge_def(edge))
+
+        return lines

osscodeiq/output/safety.py

@@ -0,0 +1,58 @@
+"""Graph size safety guard for the OSSCodeIQ CLI."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from osscodeiq.graph.store import GraphStore
+
+
+def check_graph_size(
+    store: GraphStore,
+    max_nodes: int,
+    console: Console,
+) -> None:
+    """Abort with a helpful message if *store* exceeds *max_nodes*.
+
+    Parameters
+    ----------
+    store:
+        The graph store to check.
+    max_nodes:
+        Maximum number of nodes allowed before the safety guard fires.
+    console:
+        Rich console used to print the error and suggestions.
+
+    Raises
+    ------
+    typer.Exit
+        If the node count exceeds *max_nodes*.
+    """
+    count = store.node_count
+    if count <= max_nodes:
+        return
+
+    console.print(
+        f"\n[bold red]Error:[/bold red] Graph contains "
+        f"[bold]{count:,}[/bold] nodes, which exceeds the "
+        f"safety limit of [bold]{max_nodes:,}[/bold].\n"
+    )
+    console.print("[bold yellow]Suggestions to reduce the graph size:[/bold yellow]\n")
+    console.print(
+        "  1. Use [cyan]--view architect[/cyan] to collapse detail "
+        "nodes into module-level nodes."
+    )
+    console.print(
+        "  2. Use [cyan]--focus \"node_id\" --hops 1[/cyan] to restrict "
+        "output to a small neighbourhood."
+    )
+    console.print(
+        "  3. Use [cyan]--module <name>[/cyan] to filter by module."
+    )
+    console.print(
+        "  4. Use [cyan]--max-nodes N[/cyan] to override this limit "
+        "(e.g. [cyan]--max-nodes 2000[/cyan]).\n"
+    )
+
+    raise typer.Exit(code=1)

osscodeiq/output/serializers.py

@@ -0,0 +1,42 @@
+"""JSON and YAML serializers for the OSSCodeIQ graph."""
+
+from __future__ import annotations
+
+import json
+
+import yaml
+
+from osscodeiq.models.graph import CodeGraph
+
+
+class JsonSerializer:
+    """Serialize a :class:`CodeGraph` to JSON."""
+
+    def serialize(self, graph: CodeGraph, pretty: bool = True) -> str:
+        """Return the graph as a JSON string.
+
+        Parameters
+        ----------
+        graph:
+            The code graph to serialize.
+        pretty:
+            When ``True`` (default), emit indented, human-readable JSON.
+        """
+        data = graph.model_dump(mode="json")
+        if pretty:
+            return json.dumps(data, indent=2, sort_keys=False)
+        return json.dumps(data, sort_keys=False)
+
+
+class YamlSerializer:
+    """Serialize a :class:`CodeGraph` to YAML."""
+
+    def serialize(self, graph: CodeGraph) -> str:
+        """Return the graph as a YAML string."""
+        data = graph.model_dump(mode="json")
+        return yaml.dump(
+            data,
+            default_flow_style=False,
+            sort_keys=False,
+            allow_unicode=True,
+        )

osscodeiq/parsing/__init__.py

@@ -0,0 +1,5 @@
+from osscodeiq.parsing.parser_manager import ParserManager
+
+__all__ = [
+    "ParserManager",
+]

osscodeiq/parsing/languages/base.py

@@ -0,0 +1,23 @@
+"""Abstract language support protocol for tree-sitter based parsing."""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+import tree_sitter
+
+
+@runtime_checkable
+class LanguageSupport(Protocol):
+    """Protocol that language plugins must satisfy."""
+
+    name: str
+    extensions: tuple[str, ...]
+
+    def get_language(self) -> tree_sitter.Language:
+        """Return the tree-sitter Language object for this language."""
+        ...
+
+    def get_queries(self) -> dict[str, str]:
+        """Return a mapping of query-name to tree-sitter query source."""
+        ...

osscodeiq/parsing/languages/java.py

@@ -0,0 +1,68 @@
+"""Java language support for tree-sitter parsing."""
+
+from __future__ import annotations
+
+import tree_sitter
+import tree_sitter_java
+
+
+class JavaLanguageSupport:
+    """Java language support with Spring-focused queries."""
+
+    name: str = "java"
+    extensions: tuple[str, ...] = (".java",)
+
+    def get_language(self) -> tree_sitter.Language:
+        return tree_sitter.Language(tree_sitter_java.language())
+
+    def get_queries(self) -> dict[str, str]:
+        return _JAVA_QUERIES.copy()
+
+
+# ---------------------------------------------------------------
+# Tree-sitter queries targeting Java + Spring annotation patterns
+# ---------------------------------------------------------------
+
+_JAVA_QUERIES: dict[str, str] = {
+    "annotations": """
+        (marker_annotation
+            name: (identifier) @annotation.name)
+        (annotation
+            name: (identifier) @annotation.name
+            arguments: (annotation_argument_list) @annotation.args)
+    """,
+    "class_declarations": """
+        (class_declaration
+            name: (identifier) @class.name
+            superclass: (superclass)? @class.superclass
+            interfaces: (super_interfaces)? @class.interfaces
+            body: (class_body) @class.body)
+    """,
+    "method_declarations": """
+        (method_declaration
+            (modifiers)? @method.modifiers
+            type: (_) @method.return_type
+            name: (identifier) @method.name
+            parameters: (formal_parameters) @method.params
+            body: (block)? @method.body)
+    """,
+    "interface_declarations": """
+        (interface_declaration
+            name: (identifier) @interface.name
+            body: (interface_body) @interface.body)
+    """,
+    "field_declarations": """
+        (field_declaration
+            (modifiers)? @field.modifiers
+            type: (_) @field.type
+            declarator: (variable_declarator
+                name: (identifier) @field.name))
+    """,
+    "import_declarations": """
+        (import_declaration
+            (scoped_identifier) @import.path)
+    """,
+    "string_literals": """
+        (string_literal) @string.value
+    """,
+}

osscodeiq/parsing/languages/python.py

@@ -0,0 +1,57 @@
+"""Python language support for tree-sitter parsing."""
+
+from __future__ import annotations
+
+import tree_sitter
+import tree_sitter_python
+
+
+class PythonLanguageSupport:
+    """Tree-sitter language support for Python."""
+
+    name: str = "python"
+    extensions: tuple[str, ...] = (".py",)
+
+    def get_language(self) -> tree_sitter.Language:
+        return tree_sitter.Language(tree_sitter_python.language())
+
+    def get_queries(self) -> dict[str, str]:
+        return PYTHON_QUERIES
+
+
+PYTHON_QUERIES: dict[str, str] = {
+    "function_definitions": """
+        (function_definition
+          name: (identifier) @func.name
+          parameters: (parameters) @func.params
+          body: (block) @func.body)
+    """,
+    "class_definitions": """
+        (class_definition
+          name: (identifier) @class.name
+          body: (block) @class.body)
+    """,
+    "decorators": """
+        (decorator
+          (call
+            function: (_) @decorator.name
+            arguments: (argument_list)? @decorator.args)?)
+    """,
+    "import_statements": """
+        (import_statement
+          name: (dotted_name) @import.name)
+    """,
+    "import_from": """
+        (import_from_statement
+          module_name: (dotted_name)? @import.module
+          name: (_)? @import.name)
+    """,
+    "string_literals": """
+        (string) @string
+    """,
+    "assignments": """
+        (assignment
+          left: (_) @assign.target
+          right: (_) @assign.value)
+    """,
+}

osscodeiq/parsing/languages/typescript.py

@@ -0,0 +1,95 @@
+"""TypeScript/JavaScript language support for tree-sitter parsing."""
+
+from __future__ import annotations
+
+import tree_sitter
+import tree_sitter_typescript
+
+
+class TypeScriptLanguageSupport:
+    """Tree-sitter language support for TypeScript."""
+
+    name: str = "typescript"
+    extensions: tuple[str, ...] = (".ts", ".tsx")
+
+    def get_language(self) -> tree_sitter.Language:
+        return tree_sitter.Language(tree_sitter_typescript.language_typescript())
+
+    def get_queries(self) -> dict[str, str]:
+        return TYPESCRIPT_QUERIES
+
+
+class JavaScriptLanguageSupport:
+    """Tree-sitter language support for JavaScript."""
+
+    name: str = "javascript"
+    extensions: tuple[str, ...] = (".js", ".jsx")
+
+    def get_language(self) -> tree_sitter.Language:
+        import tree_sitter_javascript
+        return tree_sitter.Language(tree_sitter_javascript.language())
+
+    def get_queries(self) -> dict[str, str]:
+        return JAVASCRIPT_QUERIES
+
+
+TYPESCRIPT_QUERIES: dict[str, str] = {
+    "class_declarations": """
+        (class_declaration
+          name: (type_identifier) @class.name
+          body: (class_body) @class.body)
+    """,
+    "method_definitions": """
+        (method_definition
+          name: (property_identifier) @method.name
+          parameters: (formal_parameters) @method.params)
+    """,
+    "function_declarations": """
+        (function_declaration
+          name: (identifier) @func.name
+          parameters: (formal_parameters) @func.params)
+    """,
+    "decorators": """
+        (decorator
+          (call_expression
+            function: (_) @decorator.name
+            arguments: (arguments)? @decorator.args))
+    """,
+    "import_statements": """
+        (import_statement
+          source: (string) @import.source)
+    """,
+    "call_expressions": """
+        (call_expression
+          function: (_) @call.func
+          arguments: (arguments) @call.args)
+    """,
+    "string_literals": """
+        (string) @string
+    """,
+}
+
+JAVASCRIPT_QUERIES: dict[str, str] = {
+    "function_declarations": """
+        (function_declaration
+          name: (identifier) @func.name
+          parameters: (formal_parameters) @func.params)
+    """,
+    "class_declarations": """
+        (class_declaration
+          name: (identifier) @class.name
+          body: (class_body) @class.body)
+    """,
+    "call_expressions": """
+        (call_expression
+          function: (_) @call.func
+          arguments: (arguments) @call.args)
+    """,
+    "import_statements": """
+        (import_statement
+          source: (string) @import.source)
+    """,
+    "string_literals": """
+        (string) @string
+    """,
+}