tree-sitter-analyzer 0.6.1__tar.gz → 0.7.0__tar.gz

{tree_sitter_analyzer-0.6.1 → tree_sitter_analyzer-0.7.0}/CHANGELOG.md

@@ -5,6 +5,79 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.0] - 2025-08-04
+
+### 🚀 Added
+
+#### Improved Table Output Structure
+- **Enhanced**: Complete restructure of `--table=full` output format
+- **Added**: Class-based organization - each class now has its own section
+- **Added**: Clear separation of fields, constructors, and methods by class
+- **Added**: Proper attribution of methods and fields to their respective classes
+- **Added**: Nested class handling - inner class members no longer appear in outer class sections
+
+#### Better Output Organization
+- **Enhanced**: File header now shows filename instead of class name for multi-class files
+- **Enhanced**: Package information displayed in dedicated section with clear formatting
+- **Enhanced**: Methods grouped by visibility (Public, Protected, Package, Private)
+- **Enhanced**: Constructors separated from regular methods
+- **Enhanced**: Fields properly attributed to their containing class
+
+#### Improved Readability
+- **Enhanced**: Cleaner section headers with line range information
+- **Enhanced**: Better visual separation between different classes
+- **Enhanced**: More logical information flow from overview to details
+
+### 🔧 Fixed
+
+#### Output Structure Issues
+- **Fixed**: Methods and fields now correctly attributed to their containing classes
+- **Fixed**: Inner class methods no longer appear duplicated in outer class sections
+- **Fixed**: Nested class field attribution corrected
+- **Fixed**: Multi-class file handling improved
+
+#### Test Updates
+- **Updated**: All tests updated to work with new output format
+- **Updated**: Package name verification tests adapted to new structure
+- **Updated**: MCP tool tests updated for new format compatibility
+
+### 📦 Package Updates
+
+- **Updated**: Table formatter completely rewritten for better organization
+- **Updated**: Class-based output structure for improved code navigation
+- **Updated**: Enhanced support for complex class hierarchies and nested classes
+
+---
+
+## [0.6.2] - 2025-08-04
+
+### 🔧 Fixed
+
+#### Java Package Name Parsing
+- **Fixed**: Java package names now display correctly instead of "unknown"
+- **Fixed**: Package name extraction works regardless of method call order
+- **Fixed**: CLI commands now show correct package names (e.g., `# com.example.service.BigService`)
+- **Fixed**: MCP tools now display proper package information
+- **Fixed**: Table formatter shows accurate package data (`| Package | com.example.service |`)
+
+#### Core Improvements
+- **Enhanced**: JavaElementExtractor now ensures package info is available before class extraction
+- **Enhanced**: JavaPlugin.analyze_file includes package elements in analysis results
+- **Enhanced**: Added robust package extraction fallback mechanism
+
+#### Testing
+- **Added**: Comprehensive regression test suite for package name parsing
+- **Added**: Verification script to prevent future package name issues
+- **Added**: Edge case testing for various package declaration patterns
+
+### 📦 Package Updates
+
+- **Updated**: Java analysis now includes Package elements in results
+- **Updated**: MCP tools provide complete package information
+- **Updated**: CLI output format consistency improved
+
+---
+
 ## [0.6.1] - 2025-08-04
 
 ### 🔧 Fixed

{tree_sitter_analyzer-0.6.1 → tree_sitter_analyzer-0.7.0}/PKG-INFO

@@ -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 → tree_sitter_analyzer-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tree-sitter-analyzer"
-version = "0.6.1"
+version = "0.7.0"
 description = "Extensible multi-language code analyzer framework using Tree-sitter with dynamic plugin architecture"
 readme = "README.md"
 requires-python = ">=3.10"

{tree_sitter_analyzer-0.6.1 → tree_sitter_analyzer-0.7.0}/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-0.6.1 → tree_sitter_analyzer-0.7.0}/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-0.6.1 → tree_sitter_analyzer-0.7.0}/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 → tree_sitter_analyzer-0.7.0}/uv.lock

@@ -1496,7 +1496,7 @@ wheels = [
 
 [[package]]
 name = "tree-sitter-analyzer"
-version = "0.6.1"
+version = "0.7.0"
 source = { editable = "." }
 dependencies = [
     { name = "cachetools" },

tree_sitter_analyzer-0.6.1/verify_release.py

@@ -1,178 +0,0 @@
-#!/usr/bin/env python3
-"""
-Release Verification Script
-Verifies that the v0.6.0 release is working correctly
-"""
-
-import subprocess
-import sys
-import tempfile
-from pathlib import Path
-
-
-def run_command(cmd, description):
-    """Run a command and return success status"""
-    print(f"\n🔍 {description}")
-    print(f"Command: {' '.join(cmd)}")
-    
-    try:
-        result = subprocess.run(
-            cmd, 
-            capture_output=True, 
-            text=True, 
-            check=True
-        )
-        print(f"✅ Success: {description}")
-        if result.stdout.strip():
-            print(f"Output: {result.stdout.strip()[:200]}...")
-        return True
-    except subprocess.CalledProcessError as e:
-        print(f"❌ Failed: {description}")
-        print(f"Error: {e.stderr.strip()}")
-        return False
-
-
-def test_local_installation():
-    """Test installation from local wheel file"""
-    print("\n" + "="*60)
-    print("🧪 TESTING LOCAL INSTALLATION")
-    print("="*60)
-    
-    wheel_file = Path("dist/tree_sitter_analyzer-0.6.0-py3-none-any.whl")
-    if not wheel_file.exists():
-        print(f"❌ Wheel file not found: {wheel_file}")
-        return False
-    
-    # Test installation in isolated environment
-    success = run_command([
-        "uv", "run", "--isolated", 
-        "--with", str(wheel_file),
-        "--with", "tree-sitter-java",
-        "python", "-c", 
-        """
-import tree_sitter_analyzer
-print(f'Package version: {tree_sitter_analyzer.__version__ if hasattr(tree_sitter_analyzer, "__version__") else "unknown"}')
-
-# Test that CodeAnalyzer is NOT available (breaking change)
-try:
-    from tree_sitter_analyzer import CodeAnalyzer
-    print('❌ ERROR: CodeAnalyzer should not be available!')
-    exit(1)
-except ImportError:
-    print('✅ CodeAnalyzer correctly removed')
-
-# Test new API
-from tree_sitter_analyzer.core.analysis_engine import get_analysis_engine
-engine = get_analysis_engine()
-print('✅ New analysis engine works')
-        """
-    ], "Test local wheel installation and API changes")
-    
-    return success
-
-
-def test_cli_functionality():
-    """Test CLI functionality"""
-    print("\n" + "="*60)
-    print("🧪 TESTING CLI FUNCTIONALITY")
-    print("="*60)
-    
-    # Create a test Java file
-    test_content = '''
-public class TestClass {
-    private String name;
-    
-    public TestClass(String name) {
-        this.name = name;
-    }
-    
-    public String getName() {
-        return name;
-    }
-}
-'''
-    
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.java', delete=False) as f:
-        f.write(test_content)
-        test_file = f.name
-    
-    try:
-        # Test CLI with local wheel
-        success = run_command([
-            "uv", "run", "--isolated",
-            "--with", "dist/tree_sitter_analyzer-0.6.0-py3-none-any.whl",
-            "--with", "tree-sitter-java",
-            "tree-sitter-analyzer", test_file, "--advanced"
-        ], "Test CLI functionality with local wheel")
-        
-        return success
-    finally:
-        Path(test_file).unlink(missing_ok=True)
-
-
-def test_pypi_installation():
-    """Test installation from PyPI (if available)"""
-    print("\n" + "="*60)
-    print("🧪 TESTING PYPI INSTALLATION")
-    print("="*60)
-    
-    # Test if package is available on PyPI
-    success = run_command([
-        "uv", "run", "--isolated",
-        "--with", "tree-sitter-analyzer==0.6.0",
-        "python", "-c",
-        """
-import tree_sitter_analyzer
-print('✅ Successfully installed from PyPI')
-
-# Test that CodeAnalyzer is NOT available
-try:
-    from tree_sitter_analyzer import CodeAnalyzer
-    print('❌ ERROR: CodeAnalyzer should not be available!')
-    exit(1)
-except ImportError:
-    print('✅ CodeAnalyzer correctly removed from PyPI package')
-        """
-    ], "Test PyPI installation")
-    
-    return success
-
-
-def main():
-    """Main verification function"""
-    print("🚀 Tree-sitter Analyzer v0.6.0 Release Verification")
-    print("="*60)
-    
-    results = []
-    
-    # Test local installation
-    results.append(("Local Installation", test_local_installation()))
-    
-    # Test CLI functionality
-    results.append(("CLI Functionality", test_cli_functionality()))
-    
-    # Test PyPI installation (may fail if not yet published)
-    results.append(("PyPI Installation", test_pypi_installation()))
-    
-    # Summary
-    print("\n" + "="*60)
-    print("📊 VERIFICATION SUMMARY")
-    print("="*60)
-    
-    all_passed = True
-    for test_name, passed in results:
-        status = "✅ PASS" if passed else "❌ FAIL"
-        print(f"{test_name:20} {status}")
-        if not passed:
-            all_passed = False
-    
-    print("\n" + "="*60)
-    if all_passed:
-        print("🎉 ALL TESTS PASSED! Release v0.6.0 is ready!")
-    else:
-        print("⚠️  Some tests failed. Please review the issues above.")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()