tree-sitter-analyzer 0.6.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

tree_sitter_analyzer/core/engine.py

@@ -301,6 +301,13 @@ class AnalysisEngine:
                     # Extract different types of elements
                     elements = []
 
+                    # Extract packages first (needed for proper class package resolution)
+                    if hasattr(extractor, "extract_packages"):
+                        packages = extractor.extract_packages(
+                            parse_result.tree, parse_result.source_code
+                        )
+                        elements.extend(packages)
+
                     # Extract functions/methods
                     if hasattr(extractor, "extract_functions"):
                         functions = extractor.extract_functions(

tree_sitter_analyzer/languages/java_plugin.py

@@ -100,6 +100,12 @@ class JavaElementExtractor(ElementExtractor):
         self.content_lines = source_code.split("\n")
         self._reset_caches()
 
+        # Ensure package information is extracted before processing classes
+        # This fixes the issue where current_package is empty when extract_classes
+        # is called independently or before extract_imports
+        if not self.current_package:
+            self._extract_package_from_tree(tree)
+
         classes: list[Class] = []
 
         # Use AdvancedAnalyzer's optimized traversal
@@ -754,6 +760,22 @@ class JavaElementExtractor(ElementExtractor):
             log_error(f"Unexpected error in package element extraction: {e}")
         return None
 
+    def _extract_package_from_tree(self, tree: "tree_sitter.Tree") -> None:
+        """
+        Extract package information from the tree and set current_package.
+
+        This method ensures that package information is available for class extraction
+        regardless of the order in which extraction methods are called.
+        """
+        try:
+            # Look for package declaration in the root node's children
+            for child in tree.root_node.children:
+                if child.type == "package_declaration":
+                    self._extract_package_info(child)
+                    break  # Only one package declaration per file
+        except Exception as e:
+            log_debug(f"Failed to extract package from tree: {e}")
+
     def _determine_visibility(self, modifiers: list[str]) -> str:
         """Determine visibility from modifiers"""
         if "public" in modifiers:
@@ -1113,6 +1135,10 @@ class JavaPlugin(LanguagePlugin):
             extractor = self.create_extractor()
 
             if parse_result.tree:
+                log_debug("Java Plugin: Extracting packages...")
+                packages = extractor.extract_packages(parse_result.tree, source_code)
+                log_debug(f"Java Plugin: Found {len(packages)} packages")
+
                 log_debug("Java Plugin: Extracting functions...")
                 functions = extractor.extract_functions(parse_result.tree, source_code)
                 log_debug(f"Java Plugin: Found {len(functions)} functions")
@@ -1129,6 +1155,7 @@ class JavaPlugin(LanguagePlugin):
                 imports = extractor.extract_imports(parse_result.tree, source_code)
                 log_debug(f"Java Plugin: Found {len(imports)} imports")
             else:
+                packages = []
                 functions = []
                 classes = []
                 variables = []
@@ -1136,6 +1163,7 @@ class JavaPlugin(LanguagePlugin):
 
             # Combine all elements
             all_elements: list[CodeElement] = []
+            all_elements.extend(packages)
             all_elements.extend(functions)
             all_elements.extend(classes)
             all_elements.extend(variables)

tree_sitter_analyzer/table_formatter.py

@@ -53,25 +53,26 @@ class TableFormatter:
         return self._convert_to_platform_newlines(result)
 
     def _format_full_table(self, data: dict[str, Any]) -> str:
-        """Full table format"""
+        """Full table format - organized by class"""
         lines = []
 
-        # Header - use filename when multiple classes exist
+        # Header - use filename for multi-class files
         classes = data.get("classes", [])
         if classes is None:
             classes = []
-        if len(classes) > 1:
-            # Use file name when multiple classes exist
-            file_name = data.get("file_path", "Unknown").split("/")[-1].split("\\")[-1]
-            lines.append(f"# {file_name}")
-        else:
-            # Use class name for single class as before
-            class_name = classes[0].get("name", "Unknown") if classes else "Unknown"
-            lines.append(
-                f"# {(data.get('package') or {}).get('name', 'unknown')}.{class_name}"
-            )
+
+        # Always use filename for header to be consistent
+        file_name = data.get("file_path", "Unknown").split("/")[-1].split("\\")[-1]
+        lines.append(f"# {file_name}")
         lines.append("")
 
+        # Package info
+        package_name = (data.get("package") or {}).get("name", "")
+        if package_name:
+            lines.append("## Package")
+            lines.append(f"`{package_name}`")
+            lines.append("")
+
         # Imports
         imports = data.get("imports", [])
         if imports:
@@ -82,12 +83,9 @@ class TableFormatter:
             lines.append("```")
             lines.append("")
 
-        # Class Info - Support for multiple classes
-        classes = data.get("classes", [])
-        if classes is None:
-            classes = []
+        # Classes Overview
         if len(classes) > 1:
-            lines.append("## Classes")
+            lines.append("## Classes Overview")
             lines.append("| Class | Type | Visibility | Lines | Methods | Fields |")
             lines.append("|-------|------|------------|-------|---------|--------|")
 
@@ -99,51 +97,198 @@ class TableFormatter:
                 lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
 
                 # Calculate method and field counts for this class
-                class_methods = [
-                    m
-                    for m in data.get("methods", [])
-                    if line_range.get("start", 0)
-                    <= m.get("line_range", {}).get("start", 0)
-                    <= line_range.get("end", 0)
-                ]
-                class_fields = [
-                    f
-                    for f in data.get("fields", [])
-                    if line_range.get("start", 0)
-                    <= f.get("line_range", {}).get("start", 0)
-                    <= line_range.get("end", 0)
-                ]
+                class_methods = self._get_class_methods(data, line_range)
+                class_fields = self._get_class_fields(data, line_range)
 
                 lines.append(
                     f"| {name} | {class_type} | {visibility} | {lines_str} | {len(class_methods)} | {len(class_fields)} |"
                 )
-        else:
-            # Use traditional format for single class
-            lines.append("## Class Info")
-            lines.append("| Property | Value |")
-            lines.append("|----------|-------|")
-
-            package_name = (data.get("package") or {}).get("name", "unknown")
-            class_info = data.get("classes", [{}])[0] if data.get("classes") else {}
-            stats = data.get("statistics") or {}
-
-            lines.append(f"| Package | {package_name} |")
-            lines.append(f"| Type | {str(class_info.get('type', 'class'))} |")
-            lines.append(
-                f"| Visibility | {str(class_info.get('visibility', 'public'))} |"
-            )
-            lines.append(
-                f"| Lines | {class_info.get('line_range', {}).get('start', 0)}-{class_info.get('line_range', {}).get('end', 0)} |"
-            )
-            lines.append(f"| Total Methods | {stats.get('method_count', 0)} |")
-            lines.append(f"| Total Fields | {stats.get('field_count', 0)} |")
+            lines.append("")
+
+        # Detailed class information - organized by class
+        for class_info in classes:
+            lines.extend(self._format_class_details(class_info, data))
+
+        # Remove trailing empty lines
+        while lines and lines[-1] == "":
+            lines.pop()
+
+        return "\n".join(lines)
+
+    def _get_class_methods(self, data: dict[str, Any], class_line_range: dict[str, int]) -> list[dict[str, Any]]:
+        """Get methods that belong to a specific class based on line range, excluding nested classes."""
+        methods = data.get("methods", [])
+        classes = data.get("classes", [])
+        class_methods = []
+
+        # Get nested class ranges to exclude their methods
+        nested_class_ranges = []
+        for cls in classes:
+            cls_range = cls.get("line_range", {})
+            cls_start = cls_range.get("start", 0)
+            cls_end = cls_range.get("end", 0)
+
+            # If this class is nested within the current class range
+            if (class_line_range.get("start", 0) < cls_start and
+                cls_end < class_line_range.get("end", 0)):
+                nested_class_ranges.append((cls_start, cls_end))
+
+        for method in methods:
+            method_line = method.get("line_range", {}).get("start", 0)
+
+            # Check if method is within the class range
+            if (class_line_range.get("start", 0) <= method_line <= class_line_range.get("end", 0)):
+                # Check if method is NOT within any nested class
+                in_nested_class = False
+                for nested_start, nested_end in nested_class_ranges:
+                    if nested_start <= method_line <= nested_end:
+                        in_nested_class = True
+                        break
+
+                if not in_nested_class:
+                    class_methods.append(method)
+
+        return class_methods
+
+    def _get_class_fields(self, data: dict[str, Any], class_line_range: dict[str, int]) -> list[dict[str, Any]]:
+        """Get fields that belong to a specific class based on line range, excluding nested classes."""
+        fields = data.get("fields", [])
+        classes = data.get("classes", [])
+        class_fields = []
+
+        # Get nested class ranges to exclude their fields
+        nested_class_ranges = []
+        for cls in classes:
+            cls_range = cls.get("line_range", {})
+            cls_start = cls_range.get("start", 0)
+            cls_end = cls_range.get("end", 0)
+
+            # If this class is nested within the current class range
+            if (class_line_range.get("start", 0) < cls_start and
+                cls_end < class_line_range.get("end", 0)):
+                nested_class_ranges.append((cls_start, cls_end))
+
+        for field in fields:
+            field_line = field.get("line_range", {}).get("start", 0)
+
+            # Check if field is within the class range
+            if (class_line_range.get("start", 0) <= field_line <= class_line_range.get("end", 0)):
+                # Check if field is NOT within any nested class
+                in_nested_class = False
+                for nested_start, nested_end in nested_class_ranges:
+                    if nested_start <= field_line <= nested_end:
+                        in_nested_class = True
+                        break
+
+                if not in_nested_class:
+                    class_fields.append(field)
+
+        return class_fields
+
+    def _format_class_details(self, class_info: dict[str, Any], data: dict[str, Any]) -> list[str]:
+        """Format detailed information for a single class."""
+        lines = []
+
+        name = str(class_info.get("name", "Unknown"))
+        line_range = class_info.get("line_range", {})
+        lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+
+        # Class header
+        lines.append(f"## {name} ({lines_str})")
+
+        # Get class-specific methods and fields
+        class_methods = self._get_class_methods(data, line_range)
+        class_fields = self._get_class_fields(data, line_range)
+
+        # Fields section
+        if class_fields:
+            lines.append("### Fields")
+            lines.append("| Name | Type | Vis | Modifiers | Line | Doc |")
+            lines.append("|------|------|-----|-----------|------|-----|")
+
+            for field in class_fields:
+                name_field = str(field.get("name", ""))
+                type_field = str(field.get("type", ""))
+                visibility = self._convert_visibility(str(field.get("visibility", "")))
+                modifiers = ",".join(field.get("modifiers", []))
+                line_num = field.get("line_range", {}).get("start", 0)
+                doc = self._extract_doc_summary(str(field.get("javadoc", ""))) if self.include_javadoc else "-"
+
+                lines.append(f"| {name_field} | {type_field} | {visibility} | {modifiers} | {line_num} | {doc} |")
+            lines.append("")
+
+        # Methods section - separate by type
+        constructors = [m for m in class_methods if m.get("is_constructor", False)]
+        regular_methods = [m for m in class_methods if not m.get("is_constructor", False)]
+
+        # Constructors
+        if constructors:
+            lines.append("### Constructors")
+            lines.append("| Constructor | Signature | Vis | Lines | Cx | Doc |")
+            lines.append("|-------------|-----------|-----|-------|----|----|")
 
+            for method in constructors:
+                lines.append(self._format_method_row_detailed(method))
+            lines.append("")
+
+        # Methods grouped by visibility
+        public_methods = [m for m in regular_methods if m.get("visibility", "") == "public"]
+        protected_methods = [m for m in regular_methods if m.get("visibility", "") == "protected"]
+        package_methods = [m for m in regular_methods if m.get("visibility", "") == "package"]
+        private_methods = [m for m in regular_methods if m.get("visibility", "") == "private"]
+
+        for method_group, title in [
+            (public_methods, "Public Methods"),
+            (protected_methods, "Protected Methods"),
+            (package_methods, "Package Methods"),
+            (private_methods, "Private Methods")
+        ]:
+            if method_group:
+                lines.append(f"### {title}")
+                lines.append("| Method | Signature | Vis | Lines | Cx | Doc |")
+                lines.append("|--------|-----------|-----|-------|----|----|")
+
+                for method in method_group:
+                    lines.append(self._format_method_row_detailed(method))
+                lines.append("")
+
+        return lines
+
+    def _format_method_row_detailed(self, method: dict[str, Any]) -> str:
+        """Format method row for detailed class view."""
+        name = str(method.get("name", ""))
+        signature = self._create_full_signature(method)
+        visibility = self._convert_visibility(str(method.get("visibility", "")))
+        line_range = method.get("line_range", {})
+        lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+        complexity = method.get("complexity_score", 0)
+        doc = self._extract_doc_summary(str(method.get("javadoc", ""))) if self.include_javadoc else "-"
+
+        return f"| {name} | {signature} | {visibility} | {lines_str} | {complexity} | {doc} |"
+
+    def _format_traditional_sections(self, data: dict[str, Any]) -> list[str]:
+        """Format traditional sections when no classes are found."""
+        lines = []
+
+        # Traditional class info
+        lines.append("## Class Info")
+        lines.append("| Property | Value |")
+        lines.append("|----------|-------|")
+
+        package_name = (data.get("package") or {}).get("name", "unknown")
+        class_info = data.get("classes", [{}])[0] if data.get("classes") else {}
+        stats = data.get("statistics") or {}
+
+        lines.append(f"| Package | {package_name} |")
+        lines.append(f"| Type | {str(class_info.get('type', 'class'))} |")
+        lines.append(f"| Visibility | {str(class_info.get('visibility', 'public'))} |")
+        lines.append(f"| Lines | {class_info.get('line_range', {}).get('start', 0)}-{class_info.get('line_range', {}).get('end', 0)} |")
+        lines.append(f"| Total Methods | {stats.get('method_count', 0)} |")
+        lines.append(f"| Total Fields | {stats.get('field_count', 0)} |")
         lines.append("")
 
         # Fields
         fields = data.get("fields", [])
-        if fields is None:
-            fields = []
         if fields:
             lines.append("## Fields")
             lines.append("| Name | Type | Vis | Modifiers | Line | Doc |")
@@ -155,66 +300,37 @@ class TableFormatter:
                 visibility = self._convert_visibility(str(field.get("visibility", "")))
                 modifiers = ",".join([str(m) for m in field.get("modifiers", [])])
                 line = field.get("line_range", {}).get("start", 0)
-                if self.include_javadoc:
-                    doc = self._extract_doc_summary(str(field.get("javadoc", "")))
-                else:
-                    doc = "-"
+                doc = self._extract_doc_summary(str(field.get("javadoc", ""))) if self.include_javadoc else "-"
 
-                lines.append(
-                    f"| {name} | {field_type} | {visibility} | {modifiers} | {line} | {doc} |"
-                )
+                lines.append(f"| {name} | {field_type} | {visibility} | {modifiers} | {line} | {doc} |")
             lines.append("")
 
-        # Constructor
-        constructors = [
-            m for m in (data.get("methods") or []) if m.get("is_constructor", False)
-        ]
+        # Methods by type
+        methods = data.get("methods", [])
+        constructors = [m for m in methods if m.get("is_constructor", False)]
+        regular_methods = [m for m in methods if not m.get("is_constructor", False)]
+
+        # Constructors
         if constructors:
             lines.append("## Constructor")
             lines.append("| Method | Signature | Vis | Lines | Cols | Cx | Doc |")
             lines.append("|--------|-----------|-----|-------|------|----|----|")
-
             for method in constructors:
                 lines.append(self._format_method_row(method))
             lines.append("")
 
-        # Public Methods
-        public_methods = [
-            m
-            for m in (data.get("methods") or [])
-            if not m.get("is_constructor", False)
-            and str(m.get("visibility")) == "public"
-        ]
-        if public_methods:
-            lines.append("## Public Methods")
-            lines.append("| Method | Signature | Vis | Lines | Cols | Cx | Doc |")
-            lines.append("|--------|-----------|-----|-------|------|----|----|")
-
-            for method in public_methods:
-                lines.append(self._format_method_row(method))
-            lines.append("")
-
-        # Private Methods
-        private_methods = [
-            m
-            for m in (data.get("methods") or [])
-            if not m.get("is_constructor", False)
-            and str(m.get("visibility")) == "private"
-        ]
-        if private_methods:
-            lines.append("## Private Methods")
-            lines.append("| Method | Signature | Vis | Lines | Cols | Cx | Doc |")
-            lines.append("|--------|-----------|-----|-------|------|----|----|")
-
-            for method in private_methods:
-                lines.append(self._format_method_row(method))
-            lines.append("")
-
-        # Remove trailing empty lines
-        while lines and lines[-1] == "":
-            lines.pop()
-
-        return "\n".join(lines)
+        # Methods by visibility
+        for visibility, title in [("public", "Public Methods"), ("private", "Private Methods")]:
+            visibility_methods = [m for m in regular_methods if str(m.get("visibility")) == visibility]
+            if visibility_methods:
+                lines.append(f"## {title}")
+                lines.append("| Method | Signature | Vis | Lines | Cols | Cx | Doc |")
+                lines.append("|--------|-----------|-----|-------|------|----|----|")
+                for method in visibility_methods:
+                    lines.append(self._format_method_row(method))
+                lines.append("")
+
+        return lines
 
     def _format_compact_table(self, data: dict[str, Any]) -> str:
         """Compact table format"""

{tree_sitter_analyzer-0.6.1.dist-info → tree_sitter_analyzer-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tree-sitter-analyzer
-Version: 0.6.1
+Version: 0.7.0
 Summary: Extensible multi-language code analyzer framework using Tree-sitter with dynamic plugin architecture
 Project-URL: Homepage, https://github.com/aimasteracc/tree-sitter-analyzer
 Project-URL: Documentation, https://github.com/aimasteracc/tree-sitter-analyzer#readme

{tree_sitter_analyzer-0.6.1.dist-info → tree_sitter_analyzer-0.7.0.dist-info}/RECORD

@@ -10,7 +10,7 @@ tree_sitter_analyzer/language_loader.py,sha256=gdLxkSoajm-q7c1vcvFONtBf5XJRgasUV
 tree_sitter_analyzer/models.py,sha256=z0aqdZOVA8rYWF0143TSAUoCvncVRLZ1O70eAjV87gU,16564
 tree_sitter_analyzer/output_manager.py,sha256=saZ8Ss6PhUJgjjwviLgrePFL7CCLMixxdKtdrpuFgHM,8146
 tree_sitter_analyzer/query_loader.py,sha256=jcJc6_kIMeZINfTVGuiEmDii9LViP_pbJfg4A9phJY4,9863
-tree_sitter_analyzer/table_formatter.py,sha256=NS8nPrgi_tjlqksRXtoPCv6NAUD4scNPH_-MQAIdU1s,17798
+tree_sitter_analyzer/table_formatter.py,sha256=6BsmXni1eiwGxLBF-nV1h8Nyya8T9bRP_obOpAE1Xic,23796
 tree_sitter_analyzer/utils.py,sha256=AarFoPxiU20y8U8ysy8G6JWK-XLMP3tUoySv6qc8nr8,7991
 tree_sitter_analyzer/cli/__init__.py,sha256=O_3URpbdu5Ilb2-r48LjbZuWtOWQu_BhL3pa6C0G3Bk,871
 tree_sitter_analyzer/cli/__main__.py,sha256=Xq8o8-0dPnMDU9WZqmqhzr98rx8rvoffTUHAkAwl-L8,218
@@ -27,7 +27,7 @@ tree_sitter_analyzer/cli/commands/table_command.py,sha256=EtMVI_Ui1wTblcDpSHWVOv
 tree_sitter_analyzer/core/__init__.py,sha256=VlYOy1epW16vjaVd__knESewnU0sfXF9a4hjrFxiSEE,440
 tree_sitter_analyzer/core/analysis_engine.py,sha256=ReWaW-ZtuyKwtR-XdVd8J-A0oN5tWmKUEyZS6LJJa8E,18567
 tree_sitter_analyzer/core/cache_service.py,sha256=TQrOI9xwI-0KRF8c6-cXwXM1Ut3AhLOXa4GpyQsIHW4,9624
-tree_sitter_analyzer/core/engine.py,sha256=6vdXcYfcHqv9tyJfT7iRPsdIIndf73wo71qT6Rt9Zow,18356
+tree_sitter_analyzer/core/engine.py,sha256=VFXGowDj6EfjFSh2MQDkQIc-4ISXaOg38n4lUhVY5Os,18721
 tree_sitter_analyzer/core/parser.py,sha256=qT3yIlTRdod4tf_2o1hU_B-GYGukyM2BtaFxzSoxois,9293
 tree_sitter_analyzer/core/query.py,sha256=fmuPMLsU4XUnMViaQADPRPoiZ-MzeE2k_e9N35VBNSA,16899
 tree_sitter_analyzer/formatters/__init__.py,sha256=yVb4HF_4EEPRwTf3y3-vM2NllrhykG3zlvQhN-6dB4c,31
@@ -41,7 +41,7 @@ tree_sitter_analyzer/interfaces/cli_adapter.py,sha256=ANl2kEirv5_mf87dlZRZvMp_oq
 tree_sitter_analyzer/interfaces/mcp_adapter.py,sha256=DJugCRVL-AR6gJRaRrBW5JVXRvfl_iiRjupcnsb0_sE,7111
 tree_sitter_analyzer/interfaces/mcp_server.py,sha256=TvcmWWRxyWp5LrbDRGAeTZww_mmyarA8Mz9eL5xiQv0,16200
 tree_sitter_analyzer/languages/__init__.py,sha256=VTXxJgVjHJAciLhX0zzXOS4EygZMtebeYUbi_0z6fGw,340
-tree_sitter_analyzer/languages/java_plugin.py,sha256=jhrOeJhp3CBMW_bjWXWwoc78DxGsLzo6YAUtkY4hJ-c,47076
+tree_sitter_analyzer/languages/java_plugin.py,sha256=o_9F_anKCemnUDV6hq28RatRmBm3e0nchcQZ-v0nDv4,48454
 tree_sitter_analyzer/languages/javascript_plugin.py,sha256=k14kHfi5II9MRTsVuy0NQq5l2KZYncCnM1Q6T1c5q_U,15844
 tree_sitter_analyzer/languages/python_plugin.py,sha256=MJ03F_Nv-nmInIkEFmPyEXYhyGbLHyr5kCbj2taEDYk,29144
 tree_sitter_analyzer/mcp/__init__.py,sha256=76ZKgWbsXZWB8mNER2D0fNHdULPZhqqBJHi8R0uHDPE,721
@@ -66,7 +66,7 @@ tree_sitter_analyzer/queries/java.py,sha256=NZTSzFADlGrm3MD0oIkOdkN_6wP2pGZpNs0R
 tree_sitter_analyzer/queries/javascript.py,sha256=pnXrgISwDE5GhPHDbUKEGI3thyLmebTeQt-l_-x4qT8,3962
 tree_sitter_analyzer/queries/python.py,sha256=L33KRUyV3sAvA3_HFkPyGgtiq0ygSpNY_n2YojodPlc,7570
 tree_sitter_analyzer/queries/typescript.py,sha256=eersyAF7TladuCWa8WE_-cO9YTF1LUSjLIl-tk2fZDo,6708
-tree_sitter_analyzer-0.6.1.dist-info/METADATA,sha256=UAy45w-jCB94SHqwqoR6iFXeHC99Lq33d4iBR4lBeQY,13410
-tree_sitter_analyzer-0.6.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tree_sitter_analyzer-0.6.1.dist-info/entry_points.txt,sha256=EA0Ow27x2SqNt2300sv70RTWxKRIxJzOhNPIVlez4NM,417
-tree_sitter_analyzer-0.6.1.dist-info/RECORD,,
+tree_sitter_analyzer-0.7.0.dist-info/METADATA,sha256=tw9dLVI_6-kKpiK_bzQ7Z-PW7XhoP9pTJpsHeq2AlUo,13410
+tree_sitter_analyzer-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tree_sitter_analyzer-0.7.0.dist-info/entry_points.txt,sha256=EA0Ow27x2SqNt2300sv70RTWxKRIxJzOhNPIVlez4NM,417
+tree_sitter_analyzer-0.7.0.dist-info/RECORD,,