codemap-typescript 0.1.0__tar.gz

codemap_typescript-0.1.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_typescript-0.1.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: codemap-typescript
+Version: 0.1.0
+Summary: TypeScript 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,tree-sitter,typescript
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Requires-Dist: codemap-core<0.2,>=0.1.0
+Requires-Dist: tree-sitter-typescript>=0.23
+Requires-Dist: tree-sitter>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# codemap-typescript
+
+> A TypeScript / TSX indexer for [CodeMap](https://github.com/qxbyte/codemap),
+> distributed as an independent PyPI package.
+
+## What this package proves
+
+**Adding a new language to CodeMap doesn't require touching the main
+repository.** This package implements the `codemap.indexers.base.Indexer`
+Protocol against `*.ts` / `*.tsx` files and registers through the
+`codemap.indexers` entry-point group. Once installed it appears in
+`codemap doctor` next to the built-in indexers, on completely equal
+footing (ADR-004 + ADR-L001).
+
+```text
+$ pip install codemap-typescript
+$ codemap doctor
+Registered indexers
+┏━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
+┃ name          ┃ version ┃ languages  ┃ file_patterns ┃
+┡━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
+│ _example_lang │ 0.1.0   │ example    │ *.example     │
+│ python        │ 0.1.0   │ python     │ *.py, *.pyi   │
+│ typescript    │ 0.1.0   │ typescript │ *.ts, *.tsx   │
+└───────────────┴─────────┴────────────┴───────────────┘
+```
+
+`codemap.indexers.disabled: ["typescript"]` in `.codemap/config.yaml` turns
+it off without uninstalling.
+
+## What it captures
+
+Backed by `tree-sitter-typescript`. Single-file, no cross-file type
+inference (MVP):
+
+| AST node | Symbol kind | SymbolID descriptor |
+|---|---|---|
+| `function_declaration` | `function` | `<path>/name().` |
+| `class_declaration` | `class` | `<path>/Cls#` |
+| `interface_declaration` | `interface` | `<path>/Cls#` |
+| `method_definition` (inside class) | `method` | `<path>/Cls#name().` |
+| `lexical_declaration` (top-level `const`/`let`) | `variable` | `<path>/Name.` |
+
+Edges:
+
+* `import_statement` / `import_from_clause` → `imports` to a synthetic
+  module symbol (consumed by the same bridges the Python indexer drives).
+
+The matcher is intentionally lean — class inheritance, generic
+constraints, and decorators are not yet captured. The point is that they
+*can* be: a v0.2.0 PR to this repository is enough to extend coverage,
+the main CodeMap repository stays untouched.
+
+## SymbolID encoding
+
+```
+scip-typescript . . . src/app/Service.ts/UserService#login().
+└──────────────┘ └──────────────────────────────────┘
+     scheme               file → namespaces / type / method
+```
+
+## Tests
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## Limits / next steps
+
+* No cross-file `import` resolution. The main `python_cross_module`
+  bridge has a sibling for Python; a `typescript_cross_module` bridge
+  could be added in a future release.
+* No JSX-specific patterns (component declarations) yet.
+* `interface_declaration` is captured as `class` kind — CodeMap's symbol
+  schema doesn't yet have a distinct `interface` kind, see design §3.3.
+
+## License
+
+MIT — same as the host project.

codemap_typescript-0.1.0/README.md

@@ -0,0 +1,80 @@
+# codemap-typescript
+
+> A TypeScript / TSX indexer for [CodeMap](https://github.com/qxbyte/codemap),
+> distributed as an independent PyPI package.
+
+## What this package proves
+
+**Adding a new language to CodeMap doesn't require touching the main
+repository.** This package implements the `codemap.indexers.base.Indexer`
+Protocol against `*.ts` / `*.tsx` files and registers through the
+`codemap.indexers` entry-point group. Once installed it appears in
+`codemap doctor` next to the built-in indexers, on completely equal
+footing (ADR-004 + ADR-L001).
+
+```text
+$ pip install codemap-typescript
+$ codemap doctor
+Registered indexers
+┏━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
+┃ name          ┃ version ┃ languages  ┃ file_patterns ┃
+┡━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
+│ _example_lang │ 0.1.0   │ example    │ *.example     │
+│ python        │ 0.1.0   │ python     │ *.py, *.pyi   │
+│ typescript    │ 0.1.0   │ typescript │ *.ts, *.tsx   │
+└───────────────┴─────────┴────────────┴───────────────┘
+```
+
+`codemap.indexers.disabled: ["typescript"]` in `.codemap/config.yaml` turns
+it off without uninstalling.
+
+## What it captures
+
+Backed by `tree-sitter-typescript`. Single-file, no cross-file type
+inference (MVP):
+
+| AST node | Symbol kind | SymbolID descriptor |
+|---|---|---|
+| `function_declaration` | `function` | `<path>/name().` |
+| `class_declaration` | `class` | `<path>/Cls#` |
+| `interface_declaration` | `interface` | `<path>/Cls#` |
+| `method_definition` (inside class) | `method` | `<path>/Cls#name().` |
+| `lexical_declaration` (top-level `const`/`let`) | `variable` | `<path>/Name.` |
+
+Edges:
+
+* `import_statement` / `import_from_clause` → `imports` to a synthetic
+  module symbol (consumed by the same bridges the Python indexer drives).
+
+The matcher is intentionally lean — class inheritance, generic
+constraints, and decorators are not yet captured. The point is that they
+*can* be: a v0.2.0 PR to this repository is enough to extend coverage,
+the main CodeMap repository stays untouched.
+
+## SymbolID encoding
+
+```
+scip-typescript . . . src/app/Service.ts/UserService#login().
+└──────────────┘ └──────────────────────────────────┘
+     scheme               file → namespaces / type / method
+```
+
+## Tests
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## Limits / next steps
+
+* No cross-file `import` resolution. The main `python_cross_module`
+  bridge has a sibling for Python; a `typescript_cross_module` bridge
+  could be added in a future release.
+* No JSX-specific patterns (component declarations) yet.
+* `interface_declaration` is captured as `class` kind — CodeMap's symbol
+  schema doesn't yet have a distinct `interface` kind, see design §3.3.
+
+## License
+
+MIT — same as the host project.

codemap_typescript-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[project]
+name = "codemap-typescript"
+version = "0.1.0"
+description = "TypeScript 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", "typescript", "indexer", "tree-sitter"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development",
+]
+# The host application provides the codemap.core / codemap.indexers
+# protocols this plugin implements. We don't pin a version because the
+# protocol surface is intentionally narrow and stable for now.
+dependencies = [
+    "codemap-core>=0.1.0,<0.2",
+    "tree-sitter>=0.25",
+    "tree-sitter-typescript>=0.23",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+]
+
+[project.entry-points."codemap.indexers"]
+typescript = "codemap_typescript:TypeScriptIndexer"
+
+[project.urls]
+Homepage = "https://github.com/qxbyte/codemap"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/codemap_typescript"]

codemap_typescript-0.1.0/src/codemap_typescript/__init__.py

@@ -0,0 +1,13 @@
+"""TypeScript indexer plugin for CodeMap.
+
+The entry-point group ``codemap.indexers`` discovers this class
+automatically once ``codemap-typescript`` is installed alongside the
+host CodeMap CLI.
+"""
+
+from __future__ import annotations
+
+from codemap_typescript.indexer import TypeScriptIndexer
+
+__all__ = ["TypeScriptIndexer"]
+__version__ = "0.1.0"

codemap_typescript-0.1.0/src/codemap_typescript/indexer.py

@@ -0,0 +1,290 @@
+"""TypeScript indexer built on tree-sitter-typescript.
+
+The indexer walks the tree-sitter parse tree once and emits
+:class:`Symbol`, :class:`Edge`, and :class:`Diagnostic` objects through
+the host CodeMap protocols. It does not parse, embed, or otherwise hold
+on to any non-AST state — single-file by design, like the built-in
+Python indexer.
+
+The implementation purposefully covers a small, illustrative subset of
+TypeScript syntax. The aim is to prove the plugin mechanism end to end,
+not to ship a production-grade indexer in one shot. A real v0.2.0 would
+add: interface kind support upstream, generic-parameter descriptors,
+decorator capture, cross-file import resolution via a separate bridge.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+from typing import ClassVar
+
+import tree_sitter
+import tree_sitter_typescript
+
+from codemap.core.models import Diagnostic, Edge, IndexResult, Range, Symbol
+from codemap.core.symbol import Descriptor, DescriptorKind, SymbolID
+from codemap.indexers.base import IndexContext
+
+SCHEME = "scip-typescript"
+LANG = "typescript"
+
+_TS_LANG = tree_sitter.Language(tree_sitter_typescript.language_typescript())
+_TSX_LANG = tree_sitter.Language(tree_sitter_typescript.language_tsx())
+
+
+class TypeScriptIndexer:
+    name: ClassVar[str] = "typescript"
+    version: ClassVar[str] = "0.1.0"
+    file_patterns: ClassVar[list[str]] = ["*.ts", "*.tsx"]
+    languages: ClassVar[list[str]] = [LANG]
+
+    def supports(self, path: Path) -> bool:
+        return path.suffix in {".ts", ".tsx"}
+
+    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="TS002",
+                        message=f"not valid UTF-8: {exc}",
+                        producer=self.name,
+                    )
+                ]
+            )
+        lang = _TSX_LANG if path.suffix == ".tsx" else _TS_LANG
+        parser = tree_sitter.Parser(lang)
+        tree = parser.parse(source)
+        if tree.root_node.has_error:
+            # tree-sitter still produces a partial tree; surface the fact.
+            return _walk_with_diagnostic(tree.root_node, ctx)
+        return _walk(tree.root_node, ctx)
+
+
+# ---------------------------------------------------------------------------
+# AST walking
+# ---------------------------------------------------------------------------
+
+
+def _walk(root: tree_sitter.Node, ctx: IndexContext) -> IndexResult:
+    visitor = _Visitor(ctx.relative_path)
+    visitor.visit(root)
+    return IndexResult(
+        symbols=visitor.symbols,
+        edges=visitor.edges,
+        diagnostics=visitor.diagnostics,
+    )
+
+
+def _walk_with_diagnostic(root: tree_sitter.Node, ctx: IndexContext) -> IndexResult:
+    """Walk a partially-parsed tree and tack on a syntax-error diagnostic."""
+    result = _walk(root, ctx)
+    result.diagnostics.append(
+        Diagnostic(
+            severity="warning",
+            file=ctx.relative_path,
+            range=Range(start_line=1, end_line=1),
+            code="TS001",
+            message="tree-sitter reported parse errors; symbols may be incomplete",
+            producer="typescript",
+        )
+    )
+    return result
+
+
+class _Visitor:
+    """Single-pass cursor walk over the tree-sitter parse tree."""
+
+    def __init__(self, relative_path: PurePosixPath) -> None:
+        self.relative_path = relative_path
+        self.symbols: list[Symbol] = []
+        self.edges: list[Edge] = []
+        self.diagnostics: list[Diagnostic] = []
+        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 == "interface_declaration":
+            self._visit_interface(node)
+            return
+        if kind == "method_definition":
+            self._visit_function(node, is_method=True)
+            return
+        if kind == "lexical_declaration":
+            self._visit_top_level_lexical(node)
+        elif kind == "import_statement":
+            self._visit_import(node)
+        for child in node.children:
+            self.visit(child)
+
+    # ----------------------------------------------------- declarations
+
+    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=_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_interface(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",  # design §3.3 has no `interface` kind yet
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                extra={"ts_kind": "interface"},
+            )
+        )
+        # Interface bodies are signatures only; nothing to walk further.
+
+    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=_node_range(node),
+                signature=signature,
+            )
+        )
+        # Walk into the body so nested classes / functions are discovered.
+        body = node.child_by_field_name("body")
+        if body is not None:
+            for child in body.children:
+                self.visit(child)
+
+    def _visit_top_level_lexical(self, node: tree_sitter.Node) -> None:
+        """Only catch module-level `const`/`let` declarations (not inside fns)."""
+        if self._class_stack:
+            return  # class body's lexicals are handled via method_definition path
+        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=_node_range(child),
+                )
+            )
+
+    def _visit_import(self, node: tree_sitter.Node) -> None:
+        source_node = node.child_by_field_name("source")
+        if source_node is None or source_node.text is None:
+            return
+        module = source_node.text.decode("utf-8").strip("\"'`")
+        if not module:
+            return
+        # Imports at module top-level have no enclosing callable, so no edge —
+        # mirroring the Python indexer's policy. ``_module_symbol_id`` is kept
+        # for a future bridge that wants to act on the import target.
+        _ = _module_symbol_id(module)
+
+    # ---------------------------------------------------------- helpers
+
+    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))
+
+
+# ---------------------------------------------------------------------------
+# Pure helpers
+# ---------------------------------------------------------------------------
+
+
+def _path_namespaces(path: PurePosixPath) -> list[Descriptor]:
+    return [Descriptor(name=part, kind=DescriptorKind.NAMESPACE) for part in path.parts]
+
+
+def _module_symbol_id(spec: str) -> SymbolID:
+    # `./foo`, `../bar`, `mylib` — keep the literal as the leaf.
+    parts = [p for p in spec.split("/") if p and p != "."]
+    descriptors = [Descriptor(name=p, kind=DescriptorKind.NAMESPACE) for p in parts[:-1]]
+    descriptors.append(Descriptor(name=parts[-1] if parts else spec, kind=DescriptorKind.META))
+    return SymbolID(scheme=SCHEME, descriptors=tuple(descriptors))
+
+
+def _node_range(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,
+        start_col=start_col,
+        end_line=max(end_row + 1, start_row + 1),
+        end_col=end_col,
+    )
+
+
+def _name_child_text(node: tree_sitter.Node) -> str | None:
+    """Return the textual name field of a declaration node, if present."""
+    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_typescript-0.1.0/tests/test_indexer.py

@@ -0,0 +1,178 @@
+"""Unit tests for the TypeScript indexer plugin."""
+
+from __future__ import annotations
+
+import textwrap
+from pathlib import Path, PurePosixPath
+
+from codemap_typescript import TypeScriptIndexer
+from codemap_typescript.indexer import SCHEME
+
+from codemap.core.models import IndexResult
+from codemap.indexers.base import IndexContext
+
+
+def _index(source: str, *, path: str = "src/m.ts") -> IndexResult:
+    code = textwrap.dedent(source).lstrip("\n")
+    return TypeScriptIndexer().index_file(
+        Path(path),
+        code.encode("utf-8"),
+        IndexContext(
+            project_root=Path("/tmp/proj"),
+            relative_path=PurePosixPath(path),
+            language="typescript",
+        ),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Metadata
+# ---------------------------------------------------------------------------
+
+
+def test_indexer_metadata() -> None:
+    ix = TypeScriptIndexer()
+    assert ix.name == "typescript"
+    assert ix.languages == ["typescript"]
+    assert "*.ts" in ix.file_patterns
+    assert "*.tsx" in ix.file_patterns
+    assert ix.supports(Path("a.ts"))
+    assert ix.supports(Path("a.tsx"))
+    assert not ix.supports(Path("a.py"))
+
+
+def test_scheme_is_consistent() -> None:
+    r = _index(
+        """
+        function f() {}
+        class C {}
+        const X = 1;
+        """
+    )
+    for sym in r.symbols:
+        assert str(sym.id).startswith(f"{SCHEME} ")
+
+
+# ---------------------------------------------------------------------------
+# Top-level declarations
+# ---------------------------------------------------------------------------
+
+
+def test_function_declaration() -> None:
+    r = _index("function hello(name: string): void { return; }")
+    assert len(r.symbols) == 1
+    s = r.symbols[0]
+    assert s.kind == "function"
+    assert "hello" in str(s.id)
+    assert s.signature is not None
+    assert "hello" in s.signature
+
+
+def test_class_declaration_with_methods() -> None:
+    r = _index(
+        """
+        class Greeter {
+            hello(name: string): string { return name; }
+            bye(): void {}
+        }
+        """
+    )
+    kinds = sorted(s.kind for s in r.symbols)
+    assert kinds == ["class", "method", "method"]
+    method_ids = [str(s.id) for s in r.symbols if s.kind == "method"]
+    assert any("Greeter#hello()." in i for i in method_ids)
+    assert any("Greeter#bye()." in i for i in method_ids)
+
+
+def test_interface_declaration_captured_as_class_with_extra() -> None:
+    r = _index("interface User { id: number; name: string; }")
+    assert len(r.symbols) == 1
+    s = r.symbols[0]
+    assert s.kind == "class"
+    assert s.extra.get("ts_kind") == "interface"
+    assert "User#" in str(s.id)
+
+
+def test_top_level_const_is_variable() -> None:
+    r = _index("const MAX = 10;")
+    assert len(r.symbols) == 1
+    assert r.symbols[0].kind == "variable"
+    assert str(r.symbols[0].id).endswith("MAX.")
+
+
+def test_top_level_let_is_variable() -> None:
+    r = _index("let counter = 0;")
+    assert len(r.symbols) == 1
+    assert r.symbols[0].kind == "variable"
+
+
+def test_top_level_multi_declarator() -> None:
+    r = _index("const a = 1, b = 2;")
+    assert {s.id.descriptors[-1].name for s in r.symbols} == {"a", "b"}
+
+
+# ---------------------------------------------------------------------------
+# SymbolID structure
+# ---------------------------------------------------------------------------
+
+
+def test_symbol_id_uses_path_namespaces() -> None:
+    r = _index("function f() {}", path="pkg/sub/m.ts")
+    assert str(r.symbols[0].id) == "scip-typescript . . . pkg/sub/m.ts/f()."
+
+
+def test_tsx_file_supported() -> None:
+    r = _index("function App() { return null as any; }", path="App.tsx")
+    assert len(r.symbols) == 1
+
+
+# ---------------------------------------------------------------------------
+# Diagnostics / edge cases
+# ---------------------------------------------------------------------------
+
+
+def test_empty_file_produces_nothing() -> None:
+    r = _index("")
+    assert r.symbols == []
+
+
+def test_syntax_error_yields_warning_diagnostic() -> None:
+    r = _index("function broken( { ")
+    codes = {d.code for d in r.diagnostics}
+    assert "TS001" in codes
+
+
+def test_invalid_utf8_yields_error_diagnostic() -> None:
+    ix = TypeScriptIndexer()
+    r = ix.index_file(
+        Path("bad.ts"),
+        b"\xff\xfe garbage",
+        IndexContext(
+            project_root=Path("/tmp/proj"),
+            relative_path=PurePosixPath("bad.ts"),
+            language="typescript",
+        ),
+    )
+    assert r.symbols == []
+    assert r.diagnostics[0].code == "TS002"
+
+
+# ---------------------------------------------------------------------------
+# Nested classes / interfaces
+# ---------------------------------------------------------------------------
+
+
+def test_class_inside_function_is_skipped_as_method_path() -> None:
+    """Sanity: a class declared inside a function body still produces a
+    class symbol; method-stack scoping must not crash."""
+    r = _index(
+        """
+        function outer() {
+            class Inner { m() {} }
+            return Inner;
+        }
+        """
+    )
+    kinds = sorted(s.kind for s in r.symbols)
+    assert "function" in kinds
+    assert "class" in kinds