fix(toml): keep every segment of a dotted key

Follow-up to #378 (@zuoYu-zzz), whose TOML extractor is otherwise sound and
whose array-table handling I could not break.

_extract_key handled a dotted_key by scanning its DIRECT children for
bare_key/quoted_key. tree-sitter-toml nests dotted_key left-recursively:

    [tool.ruff.lint]
      -> dotted_key( dotted_key( bare_key tool, bare_key ruff ), bare_key lint )

The inner dotted_key was not in the filter tuple, so every segment except the
last was dropped. Two-level paths worked, which is why it looked correct at a
glance. Three-plus levels broke, on this repo's own pyproject.toml:

    [tool.hatch.build.targets.wheel]   -> wheel             / signature [wheel]
    [tool.pytest.ini_options]          -> ini_options       / [ini_options]
    [tool.ruff.lint]                   -> lint              / [lint]
    [tool.ruff.lint.per-file-ignores]  -> per-file-ignores  / [per-file-ignores]

The signature is the sharp end. "[wheel]" is a header that appears NOWHERE in
the file, so search_symbols would hand an agent fabricated source text. And
...targets.wheel / ...targets.sdist collapse to names that collide with any
other three-deep table sharing that leaf.

_extract_key becomes _extract_key_parts, returning segments instead of a
pre-joined string and recursing on the nested dotted_key. Building from parts
also fixes name/qualified_name, which the PR set to the same value: name is now
the LEAF and qualified_name the full dotted path, the convention every other
extractor in this module already follows.

New test asserts three- and five-deep tables, a dotted key inside a table
(a.x.y.z), a dotted array table, and that a table's signature is text that
actually occurs in the source. Proven non-vacuous: restoring the single-token
bug flips it to FAIL. The PR's own test uses only single-segment headers, so
nothing in the suite could have caught this.

Docstring now records that the every-pair-at-every-depth policy diverges from
_parse_json_symbols (root-level keys only) DELIBERATELY, so nobody "fixes" it
later: TOML tables are genuinely structural, and lock files never route here
because Cargo.lock / uv.lock / poetry.lock carry no .toml extension.

Rides the next release alongside #379. No schema, tool-count, or INDEX_VERSION
change; previously-skipped .toml files simply gain correct symbols on reindex.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: jgravelle

src/jcodemunch_mcp/parser/extractor.py

@@ -6362,6 +6362,14 @@ def _parse_toml_symbols(source_bytes: bytes, filename: str) -> list[Symbol]:
     TOML tables are the primary structural units, similar to sections in INI files.
     Array tables represent lists of tables. Key-value pairs at the top level
     and inside tables are extracted as constants.
+
+    Unlike ``_parse_json_symbols``, which caps at root-level keys to avoid noise
+    in large config files, this extracts every pair at every depth. That
+    divergence is deliberate: TOML tables are genuinely structural, lock files
+    do not route here (Cargo.lock / uv.lock / poetry.lock carry no ``.toml``
+    extension), and a typical pyproject.toml yields tens of symbols, not
+    thousands. ``name`` is the leaf segment and ``qualified_name`` the full
+    dotted path, matching every other extractor in this module.
     """
     try:
         parser = get_parser("toml")
@@ -6371,20 +6379,26 @@ def _parse_toml_symbols(source_bytes: bytes, filename: str) -> list[Symbol]:
     tree = parser.parse(source_bytes)
     symbols: list[Symbol] = []
 
-    def _extract_key(node) -> Optional[str]:
-        """Extract key name from a TOML key node."""
+    def _extract_key_parts(node) -> list[str]:
+        """Extract a TOML key node as its path segments.
+
+        tree-sitter-toml nests ``dotted_key`` left-recursively, so
+        ``[tool.ruff.lint]`` is ``dotted_key(dotted_key(tool, ruff), lint)``.
+        Recursing on the nested node is what keeps every segment; matching only
+        the leaf types drops all but the last one.
+        """
         if node.type == "bare_key":
-            return source_bytes[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
+            return [source_bytes[node.start_byte:node.end_byte].decode("utf-8", errors="replace")]
         elif node.type == "quoted_key":
             content = source_bytes[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
-            return content.strip('"').strip("'")
+            return [content.strip('"').strip("'")]
         elif node.type == "dotted_key":
-            parts = []
+            parts: list[str] = []
             for child in node.children:
-                if child.type in ("bare_key", "quoted_key"):
-                    parts.append(_extract_key(child))
-            return ".".join(p for p in parts if p)
-        return None
+                if child.type in ("bare_key", "quoted_key", "dotted_key"):
+                    parts.extend(_extract_key_parts(child))
+            return [p for p in parts if p]
+        return []
 
     def _walk_node(node, parent_path: list[str] = None):
         """Walk the AST and extract symbols."""
@@ -6394,13 +6408,13 @@ def _walk_node(node, parent_path: list[str] = None):
         if node.type == "table":
             key_node = next((c for c in node.children if c.type in ("bare_key", "quoted_key", "dotted_key")), None)
             if key_node:
-                key = _extract_key(key_node)
-                if key:
-                    full_path = ".".join(parent_path + [key]) if parent_path else key
+                key_parts = _extract_key_parts(key_node)
+                if key_parts:
+                    full_path = ".".join(parent_path + key_parts)
                     symbols.append(Symbol(
                         id=make_symbol_id(filename, full_path, "type"),
                         file=filename,
-                        name=key,
+                        name=key_parts[-1],
                         qualified_name=full_path,
                         kind="type",
                         language="toml",
@@ -6411,21 +6425,21 @@ def _walk_node(node, parent_path: list[str] = None):
                         byte_length=node.end_byte - node.start_byte,
                         content_hash=compute_content_hash(source_bytes[node.start_byte:node.end_byte]),
                     ))
-                    new_path = parent_path + [key]
+                    new_path = parent_path + key_parts
                     for child in node.children:
                         _walk_node(child, new_path)
             return
 
         if node.type == "table_array_element":
             key_node = next((c for c in node.children if c.type in ("bare_key", "quoted_key", "dotted_key")), None)
             if key_node:
-                key = _extract_key(key_node)
-                if key:
-                    full_path = ".".join(parent_path + [key]) if parent_path else key
+                key_parts = _extract_key_parts(key_node)
+                if key_parts:
+                    full_path = ".".join(parent_path + key_parts)
                     symbols.append(Symbol(
                         id=make_symbol_id(filename, full_path + "[]", "class"),
                         file=filename,
-                        name=key + "[]",
+                        name=key_parts[-1] + "[]",
                         qualified_name=full_path,
                         kind="class",
                         language="toml",
@@ -6436,7 +6450,7 @@ def _walk_node(node, parent_path: list[str] = None):
                         byte_length=node.end_byte - node.start_byte,
                         content_hash=compute_content_hash(source_bytes[node.start_byte:node.end_byte]),
                     ))
-                    new_path = parent_path + [key]
+                    new_path = parent_path + key_parts
                     for child in node.children:
                         _walk_node(child, new_path)
             return
@@ -6448,17 +6462,17 @@ def _walk_node(node, parent_path: list[str] = None):
                     key_node = child
                     break
             if key_node:
-                key = _extract_key(key_node)
-                if key:
-                    full_path = ".".join(parent_path + [key]) if parent_path else key
+                key_parts = _extract_key_parts(key_node)
+                if key_parts:
+                    full_path = ".".join(parent_path + key_parts)
                     val_src = source_bytes[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
                     sig = " ".join(val_src.split())
                     if len(sig) > 100:
                         sig = sig[:97] + "..."
                     symbols.append(Symbol(
                         id=make_symbol_id(filename, full_path, "constant"),
                         file=filename,
-                        name=key,
+                        name=key_parts[-1],
                         qualified_name=full_path,
                         kind="constant",
                         language="toml",

tests/test_languages.py

@@ -2539,3 +2539,64 @@ def test_toml_extension_mapping():
     assert get_language_for_path("pyproject.toml") == "toml"
     assert get_language_for_path("config/settings.toml") == "toml"
     assert get_language_for_path("CONFIG/SETTINGS.TOML") == "toml"
+
+
+TOML_DEEP_SOURCE = '''\
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pkg"]
+
+[a]
+x.y.z = 1
+
+[[tool.pytest.suites]]
+name = "unit"
+'''
+
+
+def test_parse_toml_dotted_paths_deeper_than_two_levels():
+    """Every segment of a dotted key survives.
+
+    tree-sitter-toml nests ``dotted_key`` left-recursively, so a walker that
+    matches only leaf key types keeps the last segment and silently drops the
+    rest. Two-level paths still look right under that bug, which is why the
+    assertions below go three and five deep: ``[tool.hatch.build.targets.wheel]``
+    came back as ``wheel`` with a fabricated ``[wheel]`` signature.
+    """
+    symbols = parse_file(TOML_DEEP_SOURCE, "pyproject.toml", "toml")
+    tables = {s.qualified_name: s for s in symbols if s.kind == "type"}
+
+    assert "tool.ruff.lint" in tables
+    assert "tool.hatch.build.targets.wheel" in tables
+
+    lint = tables["tool.ruff.lint"]
+    # name is the leaf, qualified_name the full path — the convention every
+    # other extractor in extractor.py follows.
+    assert lint.name == "lint"
+    # The signature must be text that actually appears in the file.
+    assert lint.signature == "[tool.ruff.lint]"
+    assert lint.signature in TOML_DEEP_SOURCE
+
+    wheel = tables["tool.hatch.build.targets.wheel"]
+    assert wheel.name == "wheel"
+    assert wheel.signature == "[tool.hatch.build.targets.wheel]"
+
+    # Pairs inherit the full table path, and a dotted key inside a table keeps
+    # its own segments too.
+    select = next(s for s in symbols if s.qualified_name == "tool.ruff.lint.select")
+    assert select.kind == "constant"
+    assert select.name == "select"
+
+    nested_pair = next(s for s in symbols if s.qualified_name == "a.x.y.z")
+    assert nested_pair.name == "z"
+
+    # Array tables carry the full path as well.
+    suites = next(s for s in symbols if s.kind == "class")
+    assert suites.qualified_name == "tool.pytest.suites"
+    assert suites.name == "suites[]"
+    assert suites.signature == "[[tool.pytest.suites]]"