codemap-vue 0.2.0__tar.gz

codemap_vue-0.2.0/.gitignore

@@ -0,0 +1,43 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Build artifacts
+build/
+dist/
+*.egg-info/
+*.egg
+.eggs/
+
+# Test / coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+.tox/
+.mypy_cache/
+.ruff_cache/
+.benchmarks/
+
+# Virtualenv
+.venv/
+venv/
+env/
+
+# uv / pdm lockfiles (commit uv.lock once we settle)
+# uv.lock
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# CodeMap own index when dogfooding
+.codemap/

codemap_vue-0.2.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: codemap-vue
+Version: 0.2.0
+Summary: Vue SFC (.vue) 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,sfc,tree-sitter,vue
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: JavaScript
+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-javascript>=0.23
+Requires-Dist: tree-sitter>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: tree-sitter-typescript>=0.23; extra == 'dev'
+Provides-Extra: typescript
+Requires-Dist: tree-sitter-typescript>=0.23; extra == 'typescript'
+Description-Content-Type: text/markdown
+
+# codemap-vue
+
+> A Vue Single File Component (`.vue`) indexer for
+> [CodeMap](https://github.com/qxbyte/codemap), distributed as an
+> independent PyPI package.
+
+## What it captures
+
+Backed by a small regex-based SFC scanner + tree-sitter:
+
+| SFC block | Indexed | Backed by |
+|---|---|---|
+| `<template>` | ❌ Ignored | — |
+| `<script>` (`lang="js"` / default) | ✅ | `tree-sitter-javascript` (required) |
+| `<script>` (`lang="jsx"`) | ✅ | `tree-sitter-javascript` (required) |
+| `<script>` (`lang="ts"`) | ✅ (with `[typescript]` extra) | `tree-sitter-typescript` (optional) |
+| `<script>` (`lang="tsx"`) | ✅ (with `[typescript]` extra) | `tree-sitter-typescript` (optional) |
+| `<script setup>` (`lang="ts"`) | ✅ (with `[typescript]` extra) | `tree-sitter-typescript` (optional) |
+| `<style>` | ❌ Ignored | — |
+
+Inside the `<script>` block, the same symbol kinds as `codemap-javascript`
+and `codemap-typescript` are surfaced:
+
+| AST node | Symbol kind |
+|---|---|
+| `function_declaration` | `function` |
+| `class_declaration` | `class` |
+| `method_definition` (inside class) | `method` |
+| Top-level `const` / `let` / `var` | `variable` (with `extra.vue_block_lang`) |
+
+Line numbers are translated back to the original `.vue` file coordinate
+space, so `codemap get` jumps to the correct line even when the script
+block starts hundreds of lines below `<template>`.
+
+## Install
+
+```bash
+# JavaScript-only Vue projects (no <script lang="ts">):
+pip install codemap-vue
+
+# Vue projects that use TypeScript in <script setup lang="ts"> (the
+# Vue 3 default):
+pip install "codemap-vue[typescript]"
+```
+
+`tree-sitter-typescript` is an optional dependency because some Vue
+projects (Vue 2 codebases, JS-only sites) do not need it. When you index
+a `.vue` file with `<script lang="ts">` and the extra is not installed,
+the plugin emits a `VUE003` warning instead of crashing.
+
+## Implementation notes
+
+`tree-sitter-vue` is not currently published on PyPI. Rather than
+bundle a hand-compiled grammar, this plugin uses a permissive regex
+scanner (`codemap_vue.sfc.extract_script_blocks`) to locate every
+top-level `<script>` block in the SFC, read its `lang=` attribute, and
+slice out the inner bytes. The inner bytes are then handed to the
+appropriate tree-sitter grammar.
+
+The scanner is intentionally permissive about malformed input: a
+missing `</script>` closing tag still produces a block that runs to
+EOF, so indexing partial / in-progress files still yields useful
+symbols.
+
+## SymbolID encoding
+
+```
+scip-vue . . . src/components/UserList.vue/fetchUser().
+└──────┘     └────────────────────────────────────────┘
+  scheme         file → namespaces / type / method
+```
+
+## Tests
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## Limits / next steps
+
+* `<template>` contents (directives, expressions, `v-on` handlers) are
+  not parsed. A future `codemap-vue` minor release could expose
+  declared template refs (`<input ref="emailRef" />`) and `defineProps`
+  / `defineEmits` macros as symbols.
+* `<script setup>` macros (`defineProps`, `defineExpose`, …) are
+  surfaced only when they appear as ordinary function calls inside a
+  variable declaration. Treating them as first-class component-shape
+  symbols is a v0.2.x improvement.
+* Class-based component decorators (vue-class-component / vue-property-decorator)
+  are not yet captured.
+
+## License
+
+MIT — same as the host project.

codemap_vue-0.2.0/README.md

@@ -0,0 +1,95 @@
+# codemap-vue
+
+> A Vue Single File Component (`.vue`) indexer for
+> [CodeMap](https://github.com/qxbyte/codemap), distributed as an
+> independent PyPI package.
+
+## What it captures
+
+Backed by a small regex-based SFC scanner + tree-sitter:
+
+| SFC block | Indexed | Backed by |
+|---|---|---|
+| `<template>` | ❌ Ignored | — |
+| `<script>` (`lang="js"` / default) | ✅ | `tree-sitter-javascript` (required) |
+| `<script>` (`lang="jsx"`) | ✅ | `tree-sitter-javascript` (required) |
+| `<script>` (`lang="ts"`) | ✅ (with `[typescript]` extra) | `tree-sitter-typescript` (optional) |
+| `<script>` (`lang="tsx"`) | ✅ (with `[typescript]` extra) | `tree-sitter-typescript` (optional) |
+| `<script setup>` (`lang="ts"`) | ✅ (with `[typescript]` extra) | `tree-sitter-typescript` (optional) |
+| `<style>` | ❌ Ignored | — |
+
+Inside the `<script>` block, the same symbol kinds as `codemap-javascript`
+and `codemap-typescript` are surfaced:
+
+| AST node | Symbol kind |
+|---|---|
+| `function_declaration` | `function` |
+| `class_declaration` | `class` |
+| `method_definition` (inside class) | `method` |
+| Top-level `const` / `let` / `var` | `variable` (with `extra.vue_block_lang`) |
+
+Line numbers are translated back to the original `.vue` file coordinate
+space, so `codemap get` jumps to the correct line even when the script
+block starts hundreds of lines below `<template>`.
+
+## Install
+
+```bash
+# JavaScript-only Vue projects (no <script lang="ts">):
+pip install codemap-vue
+
+# Vue projects that use TypeScript in <script setup lang="ts"> (the
+# Vue 3 default):
+pip install "codemap-vue[typescript]"
+```
+
+`tree-sitter-typescript` is an optional dependency because some Vue
+projects (Vue 2 codebases, JS-only sites) do not need it. When you index
+a `.vue` file with `<script lang="ts">` and the extra is not installed,
+the plugin emits a `VUE003` warning instead of crashing.
+
+## Implementation notes
+
+`tree-sitter-vue` is not currently published on PyPI. Rather than
+bundle a hand-compiled grammar, this plugin uses a permissive regex
+scanner (`codemap_vue.sfc.extract_script_blocks`) to locate every
+top-level `<script>` block in the SFC, read its `lang=` attribute, and
+slice out the inner bytes. The inner bytes are then handed to the
+appropriate tree-sitter grammar.
+
+The scanner is intentionally permissive about malformed input: a
+missing `</script>` closing tag still produces a block that runs to
+EOF, so indexing partial / in-progress files still yields useful
+symbols.
+
+## SymbolID encoding
+
+```
+scip-vue . . . src/components/UserList.vue/fetchUser().
+└──────┘     └────────────────────────────────────────┘
+  scheme         file → namespaces / type / method
+```
+
+## Tests
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## Limits / next steps
+
+* `<template>` contents (directives, expressions, `v-on` handlers) are
+  not parsed. A future `codemap-vue` minor release could expose
+  declared template refs (`<input ref="emailRef" />`) and `defineProps`
+  / `defineEmits` macros as symbols.
+* `<script setup>` macros (`defineProps`, `defineExpose`, …) are
+  surfaced only when they appear as ordinary function calls inside a
+  variable declaration. Treating them as first-class component-shape
+  symbols is a v0.2.x improvement.
+* Class-based component decorators (vue-class-component / vue-property-decorator)
+  are not yet captured.
+
+## License
+
+MIT — same as the host project.

codemap_vue-0.2.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[project]
+name = "codemap-vue"
+version = "0.2.0"
+description = "Vue SFC (.vue) indexer plugin for CodeMap (https://github.com/qxbyte/codemap)"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "CodeMap Contributors" }]
+keywords = ["codemap", "vue", "sfc", "indexer", "tree-sitter"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: JavaScript",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development",
+]
+# tree-sitter-vue is not on PyPI. The plugin extracts the <script> block
+# via SFC top-level parsing, then dispatches to tree-sitter-javascript
+# (always required) and tree-sitter-typescript (optional, only when the
+# block declares lang="ts" / lang="tsx") for inner code.
+dependencies = [
+    "codemap-core>=0.2.0,<0.3",
+    "tree-sitter>=0.25",
+    "tree-sitter-javascript>=0.23",
+]
+
+[project.optional-dependencies]
+typescript = ["tree-sitter-typescript>=0.23"]
+dev = ["pytest>=8.0", "tree-sitter-typescript>=0.23"]
+
+[project.entry-points."codemap.indexers"]
+vue = "codemap_vue:VueIndexer"
+
+[project.urls]
+Homepage = "https://github.com/qxbyte/codemap"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/codemap_vue"]

codemap_vue-0.2.0/src/codemap_vue/__init__.py

@@ -0,0 +1,13 @@
+"""Vue SFC indexer plugin for CodeMap.
+
+The entry-point group ``codemap.indexers`` discovers this class
+automatically once ``codemap-vue`` is installed alongside the host
+CodeMap CLI.
+"""
+
+from __future__ import annotations
+
+from codemap_vue.indexer import VueIndexer
+
+__all__ = ["VueIndexer"]
+__version__ = "0.2.0a1"

codemap_vue-0.2.0/src/codemap_vue/indexer.py

@@ -0,0 +1,293 @@
+"""Vue SFC indexer.
+
+Strategy
+========
+
+``.vue`` files mix three languages — HTML-like ``<template>``,
+JS / TS in ``<script>``, and CSS / SCSS / Less in ``<style>``. Since
+``tree-sitter-vue`` is not available on PyPI, this plugin:
+
+1. Uses :mod:`codemap_vue.sfc` to locate every top-level ``<script>``
+   block in the file and read its ``lang=`` attribute.
+2. Dispatches the block's bytes to the matching tree-sitter grammar
+   (``tree-sitter-javascript`` for JS / JSX, ``tree-sitter-typescript``
+   for TS / TSX). The TypeScript grammar is an optional dependency —
+   ``.vue`` files that declare ``lang="ts"`` without it installed
+   produce a diagnostic, not a crash.
+3. Walks the inner parse tree, collecting top-level functions, classes
+   (with methods), and module-level ``const`` / ``let`` / ``var``
+   declarations. Symbol line numbers are translated from script-local
+   to file-global coordinates so ``codemap get`` jumps to the right
+   line in the ``.vue`` source.
+
+``<template>`` and ``<style>`` are intentionally ignored — they are
+covered by neither tree-sitter-javascript nor tree-sitter-typescript,
+and their template-only constructs are best served by a dedicated
+``codemap-html`` plugin if such coverage is ever needed.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+from typing import ClassVar
+
+import tree_sitter
+import tree_sitter_javascript
+
+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_vue.sfc import ScriptBlock, extract_script_blocks
+
+SCHEME = "scip-vue"
+LANG = "vue"
+
+_JS_LANG = tree_sitter.Language(tree_sitter_javascript.language())
+
+try:
+    import tree_sitter_typescript as _ts_module
+
+    _TS_LANG: tree_sitter.Language | None = tree_sitter.Language(_ts_module.language_typescript())
+    _TSX_LANG: tree_sitter.Language | None = tree_sitter.Language(_ts_module.language_tsx())
+except ImportError:  # pragma: no cover - exercised in integration only
+    _TS_LANG = None
+    _TSX_LANG = None
+
+
+class VueIndexer:
+    name: ClassVar[str] = "vue"
+    version: ClassVar[str] = "0.2.0"
+    file_patterns: ClassVar[list[str]] = ["*.vue"]
+    languages: ClassVar[list[str]] = [LANG]
+
+    def supports(self, path: Path) -> bool:
+        return path.suffix == ".vue"
+
+    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="VUE002",
+                        message=f"not valid UTF-8: {exc}",
+                        producer=self.name,
+                    )
+                ]
+            )
+
+        blocks = extract_script_blocks(source)
+        if not blocks:
+            return IndexResult()
+
+        symbols: list[Symbol] = []
+        diagnostics: list[Diagnostic] = []
+
+        for block in blocks:
+            lang_obj = _lang_for(block.lang)
+            if lang_obj is None:
+                diagnostics.append(
+                    Diagnostic(
+                        severity="warning",
+                        file=ctx.relative_path,
+                        range=Range(
+                            start_line=block.content_start_line, end_line=block.content_start_line
+                        ),
+                        code="VUE003",
+                        message=(
+                            f'<script lang="{block.lang}"> requires tree-sitter-typescript; '
+                            f"install with: pip install codemap-vue[typescript]"
+                        ),
+                        producer=self.name,
+                    )
+                )
+                continue
+
+            parser = tree_sitter.Parser(lang_obj)
+            tree = parser.parse(block.content)
+            if tree.root_node.has_error:
+                diagnostics.append(
+                    Diagnostic(
+                        severity="warning",
+                        file=ctx.relative_path,
+                        range=Range(
+                            start_line=block.content_start_line, end_line=block.content_start_line
+                        ),
+                        code="VUE001",
+                        message="tree-sitter reported parse errors inside <script>; symbols may be incomplete",
+                        producer=self.name,
+                    )
+                )
+
+            visitor = _ScriptVisitor(ctx.relative_path, block)
+            visitor.visit(tree.root_node)
+            symbols.extend(visitor.symbols)
+
+        return IndexResult(symbols=symbols, diagnostics=diagnostics)
+
+
+def _lang_for(script_lang: str) -> tree_sitter.Language | None:
+    if script_lang in {"js", "jsx"}:
+        return _JS_LANG
+    if script_lang == "ts":
+        return _TS_LANG
+    if script_lang == "tsx":
+        return _TSX_LANG
+    return _JS_LANG
+
+
+# ---------------------------------------------------------------------------
+# AST walking (mirrors codemap-typescript / codemap-javascript)
+# ---------------------------------------------------------------------------
+
+
+class _ScriptVisitor:
+    """Walks one ``<script>`` block's AST, translating positions."""
+
+    def __init__(self, relative_path: PurePosixPath, block: ScriptBlock) -> None:
+        self.relative_path = relative_path
+        self.block = block
+        self.symbols: list[Symbol] = []
+        self._class_stack: list[str] = []
+
+    def visit(self, node: tree_sitter.Node) -> None:
+        kind = node.type
+        if kind == "function_declaration":
+            self._visit_function(node, is_method=False)
+            return
+        if kind == "class_declaration":
+            self._visit_class(node)
+            return
+        if kind == "method_definition":
+            self._visit_function(node, is_method=True)
+            return
+        if kind in {"lexical_declaration", "variable_declaration"}:
+            self._visit_top_level_declaration(node)
+        for child in node.children:
+            self.visit(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 _visit_function(self, node: tree_sitter.Node, *, is_method: bool) -> None:
+        name = _name_child_text(node)
+        if name is None:
+            return
+        sid = self._make_id(name, descriptor_kind=DescriptorKind.METHOD)
+        kind: str = "method" if is_method or self._class_stack else "function"
+        signature = _function_signature(node, name)
+        self.symbols.append(
+            Symbol(
+                id=sid,
+                kind=kind,  # type: ignore[arg-type]
+                language=LANG,
+                file=self.relative_path,
+                range=self._node_range(node),
+                signature=signature,
+                extra={"vue_block_lang": self.block.lang},
+            )
+        )
+        body = node.child_by_field_name("body")
+        if body is not None:
+            for child in body.children:
+                self.visit(child)
+
+    def _visit_top_level_declaration(self, node: tree_sitter.Node) -> None:
+        if self._class_stack:
+            return
+        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.type != "identifier":
+                continue
+            name = name_node.text.decode("utf-8") if name_node.text else ""
+            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),
+                    extra={"vue_block_lang": self.block.lang},
+                )
+            )
+
+    def _make_id(self, name: str, *, descriptor_kind: DescriptorKind) -> SymbolID:
+        descriptors = list(_path_namespaces(self.relative_path))
+        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:
+        """Convert script-local row to file-global row by adding block offset."""
+        start_row, start_col = node.start_point
+        end_row, end_col = node.end_point
+        # The block's content_start_line is 1-based and is the line where
+        # the content starts; node start_row is 0-based within the block.
+        offset = self.block.content_start_line - 1
+        return Range(
+            start_line=start_row + 1 + offset,
+            start_col=start_col,
+            end_line=max(end_row + 1 + offset, start_row + 1 + offset),
+            end_col=end_col,
+        )
+
+
+# ---------------------------------------------------------------------------
+# Pure helpers (shared shape with sibling indexers)
+# ---------------------------------------------------------------------------
+
+
+def _path_namespaces(path: PurePosixPath) -> list[Descriptor]:
+    return [Descriptor(name=part, kind=DescriptorKind.NAMESPACE) for part in path.parts]
+
+
+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")
+    prefix = "function" if node.type == "function_declaration" else ""
+    return (f"{prefix} {name}{params_text}").strip()

codemap_vue-0.2.0/src/codemap_vue/sfc.py

@@ -0,0 +1,102 @@
+"""Vue SFC (Single File Component) top-level extractor.
+
+``tree-sitter-vue`` is not published on PyPI. The official Vue ecosystem
+parses ``.vue`` files with a hand-written HTML scanner from
+``@vue/compiler-sfc``; we mirror the minimum we need with a small
+regex-driven scanner that locates the top-level ``<script>`` block (and
+nothing else — ``<template>`` and ``<style>`` are deliberately ignored).
+
+The scanner is intentionally permissive about malformed input: a missing
+``</script>`` closing tag still produces a block that runs to EOF, so
+indexing partial / in-progress files still yields useful symbols.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Literal
+
+ScriptLang = Literal["ts", "tsx", "js", "jsx"]
+
+_SCRIPT_OPEN_RE = re.compile(
+    rb"<script\b([^>]*)>",  # captures attributes inside the open tag
+    re.IGNORECASE,
+)
+_SCRIPT_CLOSE_RE = re.compile(rb"</script\s*>", re.IGNORECASE)
+_LANG_ATTR_RE = re.compile(
+    rb"""\blang\s*=\s*(?P<q>["'])(?P<lang>[^"']+)(?P=q)""",
+    re.IGNORECASE,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ScriptBlock:
+    """One ``<script>`` block extracted from a .vue file.
+
+    ``lang`` is normalised to one of ``"ts" | "tsx" | "js" | "jsx"``;
+    defaults to ``"js"`` if no ``lang=`` attribute is present.
+
+    ``content`` is the **bytes between the opening and closing tag**,
+    not including the tags themselves.
+
+    ``content_start_offset`` is the byte offset within the original
+    file where ``content`` begins; it is used by the indexer to
+    translate AST line numbers back to source-file coordinates.
+
+    ``content_start_line`` is the 1-based line number in the original
+    file where ``content`` begins.
+    """
+
+    lang: ScriptLang
+    content: bytes
+    content_start_offset: int
+    content_start_line: int
+
+
+def extract_script_blocks(source: bytes) -> list[ScriptBlock]:
+    """Locate every top-level ``<script>`` block in a Vue SFC.
+
+    Standard Vue 3 SFCs hold at most two ``<script>`` blocks: a normal
+    one and a ``<script setup>`` one. We return them in the order they
+    appear. Inner blocks (nested ``<script>`` inside a string literal
+    or template) are not unlikely, but for top-level SFC parsing the
+    naive scan is correct in practice.
+    """
+    blocks: list[ScriptBlock] = []
+    cursor = 0
+    while cursor < len(source):
+        open_match = _SCRIPT_OPEN_RE.search(source, cursor)
+        if open_match is None:
+            break
+        attrs = open_match.group(1) or b""
+        content_start = open_match.end()
+        close_match = _SCRIPT_CLOSE_RE.search(source, content_start)
+        content_end = close_match.start() if close_match is not None else len(source)
+        content = source[content_start:content_end]
+        lang = _detect_lang(attrs)
+        blocks.append(
+            ScriptBlock(
+                lang=lang,
+                content=content,
+                content_start_offset=content_start,
+                content_start_line=source[:content_start].count(b"\n") + 1,
+            )
+        )
+        cursor = close_match.end() if close_match is not None else content_end
+    return blocks
+
+
+def _detect_lang(attrs: bytes) -> ScriptLang:
+    """Detect ``lang=`` from the bytes inside ``<script ...>``."""
+    match = _LANG_ATTR_RE.search(attrs)
+    if match is None:
+        return "js"
+    raw = match.group("lang").decode("ascii", errors="replace").strip().lower()
+    if raw in {"ts", "typescript"}:
+        return "ts"
+    if raw == "tsx":
+        return "tsx"
+    if raw == "jsx":
+        return "jsx"
+    return "js"

codemap_vue-0.2.0/tests/test_indexer.py

@@ -0,0 +1,208 @@
+"""Unit tests for the Vue SFC indexer plugin."""
+
+from __future__ import annotations
+
+import textwrap
+from pathlib import Path, PurePosixPath
+
+from codemap_vue import VueIndexer
+from codemap_vue.indexer import SCHEME
+from codemap_vue.sfc import extract_script_blocks
+
+from codemap.core.models import IndexResult
+from codemap.indexers.base import IndexContext
+
+
+def _index(source: str, *, path: str = "src/App.vue") -> IndexResult:
+    code = textwrap.dedent(source).lstrip("\n")
+    return VueIndexer().index_file(
+        Path(path),
+        code.encode("utf-8"),
+        IndexContext(
+            project_root=Path("/tmp/proj"),
+            relative_path=PurePosixPath(path),
+            language="vue",
+        ),
+    )
+
+
+# ---------------------------------------------------------------------------
+# SFC scanner (no parser dependency)
+# ---------------------------------------------------------------------------
+
+
+def test_extract_script_blocks_basic() -> None:
+    src = b"<template><div/></template>\n<script>const a = 1;</script>"
+    blocks = extract_script_blocks(src)
+    assert len(blocks) == 1
+    assert blocks[0].lang == "js"
+    assert b"const a = 1" in blocks[0].content
+
+
+def test_extract_script_blocks_typescript_lang() -> None:
+    src = b'<script lang="ts">const x: number = 1;</script>'
+    blocks = extract_script_blocks(src)
+    assert len(blocks) == 1
+    assert blocks[0].lang == "ts"
+
+
+def test_extract_script_blocks_setup_and_normal() -> None:
+    src = b'<script>export default {};</script>\n<script setup lang="ts">const n = 1;</script>'
+    blocks = extract_script_blocks(src)
+    assert len(blocks) == 2
+    assert [b.lang for b in blocks] == ["js", "ts"]
+
+
+def test_extract_script_blocks_no_script_returns_empty() -> None:
+    src = b"<template><p>hi</p></template>\n<style>.x{}</style>"
+    blocks = extract_script_blocks(src)
+    assert blocks == []
+
+
+def test_extract_script_blocks_missing_close_runs_to_eof() -> None:
+    src = b"<script>const x = 1;\nconst y = 2;"  # no </script>
+    blocks = extract_script_blocks(src)
+    assert len(blocks) == 1
+    assert b"const x" in blocks[0].content
+    assert b"const y" in blocks[0].content
+
+
+# ---------------------------------------------------------------------------
+# Indexer metadata
+# ---------------------------------------------------------------------------
+
+
+def test_indexer_metadata() -> None:
+    ix = VueIndexer()
+    assert ix.name == "vue"
+    assert ix.languages == ["vue"]
+    assert ix.file_patterns == ["*.vue"]
+    assert ix.supports(Path("App.vue"))
+    assert not ix.supports(Path("App.js"))
+    assert not ix.supports(Path("App.ts"))
+
+
+# ---------------------------------------------------------------------------
+# Indexer: SFC content
+# ---------------------------------------------------------------------------
+
+
+def test_vue_with_only_template_produces_nothing() -> None:
+    r = _index(
+        """
+        <template>
+            <div>hello</div>
+        </template>
+        """
+    )
+    assert r.symbols == []
+
+
+def test_vue_script_js_top_level_function() -> None:
+    r = _index(
+        """
+        <template><div/></template>
+        <script>
+        function greet(name) { return name; }
+        </script>
+        """
+    )
+    assert len(r.symbols) == 1
+    assert r.symbols[0].kind == "function"
+    assert "greet" in str(r.symbols[0].id)
+
+
+def test_vue_script_ts_top_level_class_and_method() -> None:
+    """Requires the optional [typescript] extra."""
+    try:
+        import tree_sitter_typescript  # noqa: F401
+    except ImportError:
+        return  # extra not installed; skip
+
+    r = _index(
+        """
+        <script lang="ts">
+        export class UserService {
+            login(name: string): boolean { return true; }
+        }
+        </script>
+        """
+    )
+    kinds = sorted(s.kind for s in r.symbols)
+    assert "class" in kinds
+    assert "method" in kinds
+
+
+def test_vue_script_setup_typescript_const() -> None:
+    try:
+        import tree_sitter_typescript  # noqa: F401
+    except ImportError:
+        return
+
+    r = _index(
+        """
+        <script setup lang="ts">
+        const message = 'hello';
+        </script>
+        """
+    )
+    assert any(s.kind == "variable" and "message" in str(s.id) for s in r.symbols)
+
+
+def test_vue_symbol_line_numbers_account_for_template_above() -> None:
+    """Symbol line numbers must be in the .vue file coordinate space."""
+    r = _index(
+        """
+        <template>
+            <div>line 2</div>
+            <div>line 3</div>
+            <div>line 4</div>
+        </template>
+        <script>
+        function below() { return 1; }
+        </script>
+        """
+    )
+    fn = next(s for s in r.symbols if s.kind == "function")
+    # The script block starts on a later line; ensure the symbol line is
+    # not 1 (which is what a naive plug-the-script-into-an-empty-file
+    # implementation would produce).
+    assert fn.range is not None
+    assert fn.range.start_line >= 7
+
+
+def test_symbol_id_uses_path_namespaces() -> None:
+    r = _index(
+        """
+        <script>
+        function f() {}
+        </script>
+        """,
+        path="pkg/sub/X.vue",
+    )
+    ids = [str(s.id) for s in r.symbols if s.kind == "function"]
+    assert any(i == "scip-vue . . . pkg/sub/X.vue/f()." for i in ids)
+
+
+# ---------------------------------------------------------------------------
+# Diagnostics
+# ---------------------------------------------------------------------------
+
+
+def test_invalid_utf8_yields_error_diagnostic() -> None:
+    ix = VueIndexer()
+    r = ix.index_file(
+        Path("bad.vue"),
+        b"\xff\xfe garbage",
+        IndexContext(
+            project_root=Path("/tmp/proj"),
+            relative_path=PurePosixPath("bad.vue"),
+            language="vue",
+        ),
+    )
+    assert r.symbols == []
+    assert r.diagnostics[0].code == "VUE002"
+
+
+def test_scheme_constant() -> None:
+    assert SCHEME == "scip-vue"