codemap-jsp 0.2.0__py3-none-any.whl

codemap_jsp/__init__.py

@@ -0,0 +1,13 @@
+"""JavaServer Pages (JSP) indexer plugin for CodeMap.
+
+The entry-point group ``codemap.indexers`` discovers this class
+automatically once ``codemap-jsp`` is installed alongside the host
+CodeMap CLI.
+"""
+
+from __future__ import annotations
+
+from codemap_jsp.indexer import JspIndexer
+
+__all__ = ["JspIndexer"]
+__version__ = "0.2.0a1"

codemap_jsp/indexer.py

@@ -0,0 +1,344 @@
+"""JSP (.jsp / .jspx / .tag / .tagx) indexer.
+
+Strategy
+========
+
+JSP files are HTML-shaped containers with embedded Java in
+``<%! ... %>`` (declarations) and ``<% ... %>`` (scriptlets), plus
+``<%@ page import="..." %>`` directives. We scan the file once for
+those constructs (:mod:`codemap_jsp.sfc`), then:
+
+* Parse each ``<%! ... %>`` block's Java with ``tree-sitter-java`` and
+  emit method / field / class symbols at the page level (these are the
+  generated servlet's instance members and are the only Java symbols
+  worth surfacing as a stable interface).
+* Skip scriptlet bodies (`<% ... %>`) for symbol extraction — every
+  statement in there is per-request local state, not a stable
+  interface.
+* Emit ``<form action="...">`` and ``<a href="...">`` URLs as
+  ``http_client_calls`` (consumed by the host's ``http_route`` bridge
+  to link the JSP page to its server controller).
+* Treat each ``<%@ page import="..." %>`` as a hint of dependency on
+  the cited Java type; recorded for future cross-asset bridging.
+
+``<template>``-style tags, JSTL (`<c:if>`, `<c:forEach>`), and EL
+(`${expr}`) are ignored — they have no symbol value here.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+from typing import ClassVar
+
+import tree_sitter
+import tree_sitter_java
+
+from codemap.core.models import Diagnostic, IndexResult, Range, Symbol
+from codemap.core.symbol import Descriptor, DescriptorKind, SymbolID
+from codemap.indexers.base import IndexContext
+from codemap_jsp.sfc import JspDeclaration, JspExtract, extract
+
+SCHEME = "scip-jsp"
+LANG = "jsp"
+
+_JAVA_LANG = tree_sitter.Language(tree_sitter_java.language())
+
+# Server-side JSP page is conceptually a class; the canonical name we
+# use as the enclosing type for its declared methods/fields is the file
+# basename (the JSP servlet generator does the same).
+_JSP_HTTP_CLIENT_EXTRA_KEY = "http_client_calls"
+
+
+class JspIndexer:
+    name: ClassVar[str] = "jsp"
+    version: ClassVar[str] = "0.2.0"
+    file_patterns: ClassVar[list[str]] = ["*.jsp", "*.jspx", "*.tag", "*.tagx"]
+    languages: ClassVar[list[str]] = [LANG]
+
+    def supports(self, path: Path) -> bool:
+        return path.suffix in {".jsp", ".jspx", ".tag", ".tagx"}
+
+    def index_file(
+        self,
+        path: Path,
+        source: bytes,
+        ctx: IndexContext,
+    ) -> IndexResult:
+        try:
+            source.decode("utf-8")
+        except UnicodeDecodeError as exc:
+            return IndexResult(
+                diagnostics=[
+                    Diagnostic(
+                        severity="error",
+                        file=ctx.relative_path,
+                        code="JSP002",
+                        message=f"not valid UTF-8: {exc}",
+                        producer=self.name,
+                    )
+                ]
+            )
+
+        ext = extract(source)
+        page_symbol, page_kind_sids = _emit_page_symbol(ctx.relative_path, source, ext)
+        symbols: list[Symbol] = [page_symbol]
+        diagnostics: list[Diagnostic] = []
+
+        # Parse declaration blocks for member symbols.
+        for block in ext.declarations:
+            block_symbols, block_diags = _index_declaration(
+                ctx.relative_path, block, page_kind_sids
+            )
+            symbols.extend(block_symbols)
+            diagnostics.extend(block_diags)
+
+        return IndexResult(symbols=symbols, diagnostics=diagnostics)
+
+
+def _emit_page_symbol(
+    relative_path: PurePosixPath,
+    source: bytes,
+    ext: JspExtract,
+) -> tuple[Symbol, list[Descriptor]]:
+    """Emit the page-level pseudo-class symbol.
+
+    Returns ``(page_symbol, page_type_descriptors)`` where the
+    descriptors are reused when generating IDs for member symbols.
+    """
+    page_name = _page_type_name(relative_path)
+    descriptors = [
+        *_path_namespaces(relative_path),
+        Descriptor(name=page_name, kind=DescriptorKind.TYPE),
+    ]
+    page_id = SymbolID(scheme=SCHEME, descriptors=tuple(descriptors))
+
+    extra: dict[str, object] = {
+        "jsp_imports": [{"fqcn": i.fqcn, "line": i.line} for i in ext.imports],
+        "jsp_includes": [{"path": i.path, "line": i.line} for i in ext.includes],
+    }
+    client_calls: list[dict[str, object]] = [
+        {"method": fa.method, "url": fa.url, "line": fa.line} for fa in ext.form_actions
+    ]
+    client_calls.extend({"method": "GET", "url": link.url, "line": link.line} for link in ext.links)
+    if client_calls:
+        extra[_JSP_HTTP_CLIENT_EXTRA_KEY] = client_calls
+
+    # Page range = full file
+    total_lines = source.count(b"\n") + 1
+    page_symbol = Symbol(
+        id=page_id,
+        kind="class",  # canonical "page = pseudo-class" mapping
+        language=LANG,
+        file=relative_path,
+        range=Range(start_line=1, end_line=total_lines),
+        extra=extra,
+    )
+    return page_symbol, descriptors
+
+
+def _index_declaration(
+    relative_path: PurePosixPath,
+    block: JspDeclaration,
+    page_type_descriptors: list[Descriptor],
+) -> tuple[list[Symbol], list[Diagnostic]]:
+    """Parse the Java member declarations in a ``<%! ... %>`` block.
+
+    JSP declaration blocks are conceptually class-body content of the
+    generated servlet, but tree-sitter-java's top-level grammar treats
+    a bare ``private int x = 0;`` as a ``local_variable_declaration``
+    rather than a ``field_declaration``. To get the right node kinds,
+    we wrap the block in a synthetic ``class _S { ... }`` frame and
+    walk inside that wrapper. The synthetic class itself contributes
+    one extra line at the top, which we subtract from every emitted
+    symbol's line number.
+    """
+    parser = tree_sitter.Parser(_JAVA_LANG)
+    wrapped = b"class _S {\n" + block.content + b"\n}"
+    tree = parser.parse(wrapped)
+    diagnostics: list[Diagnostic] = []
+    if tree.root_node.has_error:
+        diagnostics.append(
+            Diagnostic(
+                severity="warning",
+                file=relative_path,
+                range=Range(start_line=block.content_start_line, end_line=block.content_start_line),
+                code="JSP001",
+                message="tree-sitter reported parse errors inside <%! ... %>; symbols may be incomplete",
+                producer=LANG,
+            )
+        )
+
+    # The wrapper class contributes one extra line ("class _S {") above
+    # the real content. Walk into the wrapper's body so we see field /
+    # method / nested class declarations as Java grammar nodes.
+    visitor = _DeclarationVisitor(
+        relative_path=relative_path,
+        # block_offset_line - 1 maps "row 0 in inner tree" to the first
+        # actual content line of the JSP file. The wrapper's "class _S {"
+        # is on row 0 of the parsed tree so its content begins on row 1,
+        # which corresponds to block.content_start_line. Net offset: -1.
+        block_offset_line=block.content_start_line - 1 - 1,
+        page_type_descriptors=page_type_descriptors,
+        synthetic_wrapper="_S",
+    )
+    visitor.visit(tree.root_node)
+    return visitor.symbols, diagnostics
+
+
+# ---------------------------------------------------------------------------
+# Java AST walking inside <%! ... %>
+# ---------------------------------------------------------------------------
+
+
+class _DeclarationVisitor:
+    """Walk one <%! ... %> block's Java AST and emit member symbols."""
+
+    def __init__(
+        self,
+        relative_path: PurePosixPath,
+        block_offset_line: int,
+        page_type_descriptors: list[Descriptor],
+        synthetic_wrapper: str | None = None,
+    ) -> None:
+        self.relative_path = relative_path
+        self.offset = block_offset_line
+        self.page_type_descriptors = page_type_descriptors
+        # When a synthetic ``class _S { ... }`` is used to coerce
+        # tree-sitter-java into emitting field_declaration nodes, we
+        # filter the wrapper itself out of the symbol stream.
+        self._synthetic_wrapper = synthetic_wrapper
+        self.symbols: list[Symbol] = []
+        self._class_stack: list[str] = []
+
+    def visit(self, node: tree_sitter.Node) -> None:
+        kind = node.type
+        if kind == "method_declaration":
+            self._visit_method(node)
+            return
+        if kind == "field_declaration":
+            self._visit_field(node)
+            return
+        if kind == "class_declaration":
+            name = _name_child_text(node)
+            if name == self._synthetic_wrapper:
+                # Walk into the wrapper's body but do not emit a symbol.
+                body = node.child_by_field_name("body")
+                if body is not None:
+                    for child in body.children:
+                        self.visit(child)
+                return
+            self._visit_class(node)
+            return
+        for child in node.children:
+            self.visit(child)
+
+    def _visit_method(self, node: tree_sitter.Node) -> None:
+        name = _name_child_text(node)
+        if name is None:
+            return
+        sid = self._make_id(name, descriptor_kind=DescriptorKind.METHOD)
+        signature = _function_signature(node, name)
+        self.symbols.append(
+            Symbol(
+                id=sid,
+                kind="method",
+                language=LANG,
+                file=self.relative_path,
+                range=self._node_range(node),
+                signature=signature,
+            )
+        )
+
+    def _visit_field(self, node: tree_sitter.Node) -> None:
+        # field_declaration: type + variable_declarator[+]
+        for child in node.children:
+            if child.type != "variable_declarator":
+                continue
+            name_node = child.child_by_field_name("name")
+            if name_node is None or name_node.text is None:
+                continue
+            name = name_node.text.decode("utf-8")
+            if not name:
+                continue
+            sid = self._make_id(name, descriptor_kind=DescriptorKind.TERM)
+            self.symbols.append(
+                Symbol(
+                    id=sid,
+                    kind="variable",
+                    language=LANG,
+                    file=self.relative_path,
+                    range=self._node_range(child),
+                )
+            )
+
+    def _visit_class(self, node: tree_sitter.Node) -> None:
+        name = _name_child_text(node)
+        if name is None:
+            return
+        sid = self._make_id(name, descriptor_kind=DescriptorKind.TYPE)
+        self.symbols.append(
+            Symbol(
+                id=sid,
+                kind="class",
+                language=LANG,
+                file=self.relative_path,
+                range=self._node_range(node),
+            )
+        )
+        self._class_stack.append(name)
+        try:
+            body = node.child_by_field_name("body")
+            if body is not None:
+                for child in body.children:
+                    self.visit(child)
+        finally:
+            self._class_stack.pop()
+
+    def _make_id(self, name: str, *, descriptor_kind: DescriptorKind) -> SymbolID:
+        descriptors = list(self.page_type_descriptors)
+        descriptors.extend(
+            Descriptor(name=cls, kind=DescriptorKind.TYPE) for cls in self._class_stack
+        )
+        descriptors.append(Descriptor(name=name, kind=descriptor_kind))
+        return SymbolID(scheme=SCHEME, descriptors=tuple(descriptors))
+
+    def _node_range(self, node: tree_sitter.Node) -> Range:
+        start_row, start_col = node.start_point
+        end_row, end_col = node.end_point
+        return Range(
+            start_line=start_row + 1 + self.offset,
+            start_col=start_col,
+            end_line=max(end_row + 1 + self.offset, start_row + 1 + self.offset),
+            end_col=end_col,
+        )
+
+
+# ---------------------------------------------------------------------------
+# Pure helpers
+# ---------------------------------------------------------------------------
+
+
+def _path_namespaces(path: PurePosixPath) -> list[Descriptor]:
+    return [Descriptor(name=part, kind=DescriptorKind.NAMESPACE) for part in path.parts]
+
+
+def _page_type_name(path: PurePosixPath) -> str:
+    """Map ``foo/bar/UserList.jsp`` → ``UserList``."""
+    stem = path.stem
+    return stem or path.name
+
+
+def _name_child_text(node: tree_sitter.Node) -> str | None:
+    name_node = node.child_by_field_name("name")
+    if name_node is None or name_node.text is None:
+        return None
+    text = name_node.text.decode("utf-8").strip()
+    return text or None
+
+
+def _function_signature(node: tree_sitter.Node, name: str) -> str:
+    params = node.child_by_field_name("parameters")
+    params_text = ""
+    if params is not None and params.text is not None:
+        params_text = params.text.decode("utf-8")
+    return f"{name}{params_text}".strip()

codemap_jsp/sfc.py

@@ -0,0 +1,232 @@
+"""JSP top-level construct extractor.
+
+``tree-sitter-jsp`` does not exist on PyPI. This module locates the
+JSP-specific constructs that matter for indexing:
+
+* ``<%@ page import="..." %>`` — type imports (one or more comma-separated)
+* ``<%@ include file="..." %>`` — server-side file inclusion
+* ``<%! ... %>`` — declaration blocks (Java member declarations:
+  fields, methods, classes that live at the *generated servlet* scope)
+* ``<% ... %>`` — scriptlets (Java statements that live at servlet
+  ``_jspService`` scope; locals here are private to one request and we
+  intentionally do not surface them as symbols)
+* ``<form action="..." method="...">`` — HTML form submissions, useful
+  for the ``http_route`` bridge to link the page to a server controller
+* ``<a href="...">`` — links to other pages or actions, same purpose
+
+Anything else (`<c:forEach>`, EL `${...}`, custom tags) is ignored.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+# JSP directive: <%@ page ... %> / <%@ include ... %> / <%@ taglib ... %>
+_DIRECTIVE_RE = re.compile(
+    rb"<%@\s*(?P<name>\w+)\s+(?P<body>[^%]*?)%>",
+    re.DOTALL,
+)
+
+# Declarations: <%! ... %>
+_DECLARATION_RE = re.compile(rb"<%!\s*(?P<body>.*?)%>", re.DOTALL)
+
+# Scriptlets: <% ... %>   — excludes <%! ... %> and <%@ ... %> directives,
+# captured separately above. We use a negative-lookahead on `!` and `@`.
+_SCRIPTLET_RE = re.compile(rb"<%(?![@!])\s*(?P<body>.*?)%>", re.DOTALL)
+
+# HTML form action / link href (case-insensitive). These let the
+# http_route bridge match a JSP page to its server-side controller.
+_FORM_ACTION_RE = re.compile(
+    rb"""<form\b[^>]*?\baction\s*=\s*(?P<q>["'])(?P<url>[^"']+)(?P=q)[^>]*?>""",
+    re.IGNORECASE,
+)
+_FORM_METHOD_RE = re.compile(
+    rb"""<form\b[^>]*?\bmethod\s*=\s*(?P<q>["'])(?P<method>[^"']+)(?P=q)""",
+    re.IGNORECASE,
+)
+_A_HREF_RE = re.compile(
+    rb"""<a\b[^>]*?\bhref\s*=\s*(?P<q>["'])(?P<url>[^"']+)(?P=q)""",
+    re.IGNORECASE,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class JspImport:
+    """One ``<%@ page import="..." %>`` entry. Java FQCN."""
+
+    fqcn: str
+    line: int
+
+
+@dataclass(frozen=True, slots=True)
+class JspInclude:
+    """One ``<%@ include file="..." %>`` directive."""
+
+    path: str
+    line: int
+
+
+@dataclass(frozen=True, slots=True)
+class JspDeclaration:
+    """One ``<%! ... %>`` block — Java member declarations."""
+
+    content: bytes
+    content_start_offset: int
+    content_start_line: int
+
+
+@dataclass(frozen=True, slots=True)
+class JspScriptlet:
+    """One ``<% ... %>`` block — Java statements in _jspService."""
+
+    content: bytes
+    content_start_offset: int
+    content_start_line: int
+
+
+@dataclass(frozen=True, slots=True)
+class JspFormAction:
+    """One ``<form action="..." method="...">``."""
+
+    method: str
+    url: str
+    line: int
+
+
+@dataclass(frozen=True, slots=True)
+class JspLink:
+    """One ``<a href="...">``."""
+
+    url: str
+    line: int
+
+
+@dataclass(frozen=True, slots=True)
+class JspExtract:
+    """All JSP-relevant constructs found in one file."""
+
+    imports: list[JspImport]
+    includes: list[JspInclude]
+    declarations: list[JspDeclaration]
+    scriptlets: list[JspScriptlet]
+    form_actions: list[JspFormAction]
+    links: list[JspLink]
+
+
+def extract(source: bytes) -> JspExtract:
+    """Scan a JSP file's bytes once and return everything we care about."""
+    return JspExtract(
+        imports=_extract_imports(source),
+        includes=_extract_includes(source),
+        declarations=_extract_declarations(source),
+        scriptlets=_extract_scriptlets(source),
+        form_actions=_extract_form_actions(source),
+        links=_extract_links(source),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Implementation details
+# ---------------------------------------------------------------------------
+
+
+def _line_of(source: bytes, offset: int) -> int:
+    return source[:offset].count(b"\n") + 1
+
+
+def _extract_imports(source: bytes) -> list[JspImport]:
+    out: list[JspImport] = []
+    for m in _DIRECTIVE_RE.finditer(source):
+        name = m.group("name").decode("ascii", errors="replace").lower()
+        if name != "page":
+            continue
+        body = m.group("body").decode("utf-8", errors="replace")
+        for attr_value in _attr_values(body, "import"):
+            # `import="java.util.List, java.util.Map"` → 2 FQCNs
+            out.extend(
+                JspImport(fqcn=fqcn, line=_line_of(source, m.start()))
+                for fqcn in (s.strip() for s in attr_value.split(","))
+                if fqcn
+            )
+    return out
+
+
+def _extract_includes(source: bytes) -> list[JspInclude]:
+    out: list[JspInclude] = []
+    for m in _DIRECTIVE_RE.finditer(source):
+        name = m.group("name").decode("ascii", errors="replace").lower()
+        if name != "include":
+            continue
+        body = m.group("body").decode("utf-8", errors="replace")
+        out.extend(
+            JspInclude(path=attr_value, line=_line_of(source, m.start()))
+            for attr_value in _attr_values(body, "file")
+            if attr_value
+        )
+    return out
+
+
+def _extract_declarations(source: bytes) -> list[JspDeclaration]:
+    out: list[JspDeclaration] = []
+    for m in _DECLARATION_RE.finditer(source):
+        body = m.group("body")
+        content_start = m.start("body")
+        out.append(
+            JspDeclaration(
+                content=body,
+                content_start_offset=content_start,
+                content_start_line=_line_of(source, content_start),
+            )
+        )
+    return out
+
+
+def _extract_scriptlets(source: bytes) -> list[JspScriptlet]:
+    out: list[JspScriptlet] = []
+    for m in _SCRIPTLET_RE.finditer(source):
+        body = m.group("body")
+        content_start = m.start("body")
+        out.append(
+            JspScriptlet(
+                content=body,
+                content_start_offset=content_start,
+                content_start_line=_line_of(source, content_start),
+            )
+        )
+    return out
+
+
+def _extract_form_actions(source: bytes) -> list[JspFormAction]:
+    out: list[JspFormAction] = []
+    for m in _FORM_ACTION_RE.finditer(source):
+        url = m.group("url").decode("utf-8", errors="replace")
+        method_match = _FORM_METHOD_RE.search(m.group(0))
+        method = (
+            method_match.group("method").decode("ascii", errors="replace").upper()
+            if method_match is not None
+            else "GET"
+        )
+        out.append(JspFormAction(method=method, url=url, line=_line_of(source, m.start())))
+    return out
+
+
+def _extract_links(source: bytes) -> list[JspLink]:
+    out: list[JspLink] = []
+    for m in _A_HREF_RE.finditer(source):
+        url = m.group("url").decode("utf-8", errors="replace")
+        # Skip pure anchors / fragments / javascript: pseudo-protocol.
+        if url.startswith(("#", "javascript:", "mailto:", "tel:")):
+            continue
+        out.append(JspLink(url=url, line=_line_of(source, m.start())))
+    return out
+
+
+def _attr_values(body: str, attr_name: str) -> list[str]:
+    """Pick attribute values from a directive body, e.g.
+
+    ``import="java.util.List" contentType="text/html"`` →
+    ``_attr_values(body, "import")`` returns ``["java.util.List"]``.
+    """
+    pattern = rf"""\b{re.escape(attr_name)}\s*=\s*(?P<q>["'])(?P<value>[^"']*)(?P=q)"""
+    return [m.group("value") for m in re.finditer(pattern, body)]

codemap_jsp-0.2.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: codemap-jsp
+Version: 0.2.0
+Summary: JavaServer Pages (.jsp) indexer plugin for CodeMap (https://github.com/qxbyte/codemap)
+Project-URL: Homepage, https://github.com/qxbyte/codemap
+Author: CodeMap Contributors
+License: MIT
+Keywords: codemap,indexer,java,jsp,tree-sitter
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Java
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Requires-Dist: codemap-core<0.3,>=0.2.0
+Requires-Dist: tree-sitter-java>=0.23
+Requires-Dist: tree-sitter>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# codemap-jsp
+
+> A JavaServer Pages (`.jsp`) indexer for
+> [CodeMap](https://github.com/qxbyte/codemap), distributed as an
+> independent PyPI package. Targets legacy Java web projects that
+> still ship `.jsp` views.
+
+## What it captures
+
+JSP files are HTML containers with embedded Java. The indexer scans
+five top-level constructs:
+
+| JSP construct | Captured as |
+|---|---|
+| `<%@ page import="..." %>` | `extra.jsp_imports` on the page symbol |
+| `<%@ include file="..." %>` | `extra.jsp_includes` on the page symbol |
+| `<%! ... %>` (declaration block) | Java members parsed by `tree-sitter-java`; methods → `method`, fields → `variable`, nested classes → `class` |
+| `<% ... %>` (scriptlet) | **Skipped** — scriptlet locals are per-request state, not a stable interface |
+| `<form action="..." method="..."/>` and `<a href="...">` | `extra.http_client_calls` on the page symbol — consumed by the host's `http_route` bridge to link the page to its server controller |
+
+Every JSP file produces **one page-level pseudo-class symbol** plus
+zero or more member symbols from any `<%! ... %>` blocks. The page
+name is derived from the file basename (`UserList.jsp` → `UserList`).
+
+## Why this matters for AI agents on legacy projects
+
+A typical Spring MVC + JSP project has:
+
+```
+src/main/java/com/example/UserController.java
+  @PostMapping("/api/users") void create(User u) { ... }
+
+src/main/webapp/WEB-INF/views/users.jsp
+  <form action="/api/users" method="POST"> ... </form>
+```
+
+The `http_route` bridge ships in `codemap-core`. Once both files are
+indexed, the bridge sees:
+
+* the server route `(POST, /api/users)` exposed by `UserController.create`
+* the client call `(POST, /api/users)` advertised by `users.jsp`
+
+…and adds a `calls` edge from the page to the controller. AI agents
+can now answer "what JSP pages submit to this controller?" with a
+single `codemap callers` query — no grepping HTML for URLs.
+
+## Install
+
+```bash
+pip install codemap-jsp
+```
+
+`tree-sitter-java` is a hard dependency (used to parse declaration
+blocks). No tree-sitter-jsp grammar is needed.
+
+## SymbolID encoding
+
+```
+scip-jsp . . . src/main/webapp/views/UserList.jsp/UserList#tag().
+└──────┘     └──────────────────────────────────────────────────┘
+  scheme         path / page pseudo-class / member
+```
+
+## Tests
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## Limits / next steps
+
+* Scriptlet (`<% ... %>`) bodies are not indexed for symbol extraction
+  — they would surface per-request locals as noise. A future v0.2.x
+  could optionally extract control-flow shape from scriptlets to
+  support cross-page navigation.
+* JSTL tags (`<c:if>`, `<c:forEach>`) and EL expressions (`${...}`)
+  are not parsed. A `codemap-jstl` companion plugin could surface
+  declared `<c:set var="..."/>` variables if there's demand.
+* Tag files (`.tag` / `.tagx`) are supported on the same code path as
+  pages but their unique `<%@ attribute name="..." %>` directives are
+  not yet surfaced as individual symbols.
+
+## License
+
+MIT — same as the host project.

codemap_jsp-0.2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+codemap_jsp/__init__.py,sha256=etJ0bN6qBa9isqOP6jgacwhVQxX9sx6eKI2ocJfLP6w,333
+codemap_jsp/indexer.py,sha256=COiYkoeReNMoNKoebqrIpDdyU6_FHT5ZeCl9WnucH2s,12761
+codemap_jsp/sfc.py,sha256=Ylwjj8Z38R5siVj8aTdjeYGjef25oAbo84ANwEqq7R8,7457
+codemap_jsp-0.2.0.dist-info/METADATA,sha256=ePdd9U58gKJTqeSGV8WbyQrMpLYZkfM7mTjTFkraDVg,3880
+codemap_jsp-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+codemap_jsp-0.2.0.dist-info/entry_points.txt,sha256=m6C01FyVzUov2zTqJY4A3_4oiolQlAiGGl3BM6FiXZ8,48
+codemap_jsp-0.2.0.dist-info/RECORD,,

codemap_jsp-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

codemap_jsp-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[codemap.indexers]
+jsp = codemap_jsp:JspIndexer