tree-sitter-analyzer 1.1.3__py3-none-any.whl → 1.2.2__py3-none-any.whl

tree_sitter_analyzer/cli/commands/advanced_command.py

@@ -7,6 +7,13 @@ Handles advanced analysis functionality.
 
 from typing import TYPE_CHECKING
 
+from ...constants import (
+    ELEMENT_TYPE_CLASS,
+    ELEMENT_TYPE_FUNCTION,
+    ELEMENT_TYPE_IMPORT,
+    ELEMENT_TYPE_VARIABLE,
+    get_element_type,
+)
 from ...output_manager import output_data, output_json, output_section
 from .base_command import BaseCommand
 
@@ -29,6 +36,111 @@ class AdvancedCommand(BaseCommand):
 
         return 0
 
+    def _calculate_file_metrics(self, file_path: str, language: str) -> dict[str, int]:
+        """
+        Calculate accurate file metrics including line counts.
+
+        Args:
+            file_path: Path to the file to analyze
+            language: Programming language
+
+        Returns:
+            Dictionary containing file metrics
+        """
+        try:
+            with open(file_path, encoding="utf-8") as f:
+                content = f.read()
+
+            lines = content.split("\n")
+            total_lines = len(lines)
+
+            # Remove empty line at the end if file ends with newline
+            if lines and not lines[-1]:
+                total_lines -= 1
+
+            # Count different types of lines
+            code_lines = 0
+            comment_lines = 0
+            blank_lines = 0
+            in_multiline_comment = False
+
+            for line in lines:
+                stripped = line.strip()
+
+                # Check for blank lines first
+                if not stripped:
+                    blank_lines += 1
+                    continue
+
+                # Check if we're in a multi-line comment
+                if in_multiline_comment:
+                    comment_lines += 1
+                    # Check if this line ends the multi-line comment
+                    if "*/" in stripped:
+                        in_multiline_comment = False
+                    continue
+
+                # Check for multi-line comment start
+                if stripped.startswith("/**") or stripped.startswith("/*"):
+                    comment_lines += 1
+                    # Check if this line also ends the comment
+                    if "*/" not in stripped:
+                        in_multiline_comment = True
+                    continue
+
+                # Check for single-line comments
+                if stripped.startswith("//"):
+                    comment_lines += 1
+                    continue
+
+                # Check for JavaDoc continuation lines (lines starting with * but not */)
+                if stripped.startswith("*") and not stripped.startswith("*/"):
+                    comment_lines += 1
+                    continue
+
+                # Check for other comment types based on language
+                if language == "python" and stripped.startswith("#"):
+                    comment_lines += 1
+                    continue
+                elif language == "sql" and stripped.startswith("--"):
+                    comment_lines += 1
+                    continue
+                elif language in ["html", "xml"] and stripped.startswith("<!--"):
+                    comment_lines += 1
+                    if "-->" not in stripped:
+                        in_multiline_comment = True
+                    continue
+                elif in_multiline_comment and "-->" in stripped:
+                    comment_lines += 1
+                    in_multiline_comment = False
+                    continue
+
+                # If not a comment, it's code
+                code_lines += 1
+
+            # Ensure the sum equals total_lines (handle any rounding errors)
+            calculated_total = code_lines + comment_lines + blank_lines
+            if calculated_total != total_lines:
+                # Adjust blank_lines to match total (since it's most likely to be off by 1)
+                blank_lines = total_lines - code_lines - comment_lines
+                # Ensure blank_lines is not negative
+                blank_lines = max(0, blank_lines)
+
+            return {
+                "total_lines": total_lines,
+                "code_lines": code_lines,
+                "comment_lines": comment_lines,
+                "blank_lines": blank_lines,
+            }
+        except Exception:
+            # Fallback to basic counting if file read fails
+            return {
+                "total_lines": 0,
+                "code_lines": 0,
+                "comment_lines": 0,
+                "blank_lines": 0,
+            }
+
     def _output_statistics(self, analysis_result: "AnalysisResult") -> None:
         """Output statistics only."""
         stats = {
@@ -57,7 +169,7 @@ class AdvancedCommand(BaseCommand):
                 "elements": [
                     {
                         "name": getattr(element, "name", str(element)),
-                        "type": getattr(element, "__class__", type(element)).__name__,
+                        "type": get_element_type(element),
                         "start_line": getattr(element, "start_line", 0),
                         "end_line": getattr(element, "end_line", 0),
                     }
@@ -77,12 +189,39 @@ class AdvancedCommand(BaseCommand):
         output_data(f"Lines: {analysis_result.line_count}")
 
         element_counts: dict[str, int] = {}
+        complexity_scores: list[int] = []
+
         for element in analysis_result.elements:
-            element_type = getattr(element, "__class__", type(element)).__name__
+            element_type = get_element_type(element)
             element_counts[element_type] = element_counts.get(element_type, 0) + 1
 
-        output_data(f"Classes: {element_counts.get('Class', 0)}")
-        output_data(f"Methods: {element_counts.get('Function', 0)}")
-        output_data(f"Fields: {element_counts.get('Variable', 0)}")
-        output_data(f"Imports: {element_counts.get('Import', 0)}")
+            # Collect complexity scores for methods
+            if element_type == ELEMENT_TYPE_FUNCTION:
+                complexity = getattr(element, "complexity_score", 1)
+                complexity_scores.append(complexity)
+
+        # Calculate accurate file metrics
+        file_metrics = self._calculate_file_metrics(
+            analysis_result.file_path, analysis_result.language
+        )
+
+        # Calculate complexity statistics
+        total_complexity = sum(complexity_scores) if complexity_scores else 0
+        avg_complexity = (
+            total_complexity / len(complexity_scores) if complexity_scores else 0
+        )
+        max_complexity = max(complexity_scores) if complexity_scores else 0
+
+        output_data(f"Classes: {element_counts.get(ELEMENT_TYPE_CLASS, 0)}")
+        output_data(f"Methods: {element_counts.get(ELEMENT_TYPE_FUNCTION, 0)}")
+        output_data(f"Fields: {element_counts.get(ELEMENT_TYPE_VARIABLE, 0)}")
+        output_data(f"Imports: {element_counts.get(ELEMENT_TYPE_IMPORT, 0)}")
         output_data("Annotations: 0")
+
+        # Add detailed metrics using accurate calculations
+        output_data(f"Code Lines: {file_metrics['code_lines']}")
+        output_data(f"Comment Lines: {file_metrics['comment_lines']}")
+        output_data(f"Blank Lines: {file_metrics['blank_lines']}")
+        output_data(f"Total Complexity: {total_complexity}")
+        output_data(f"Average Complexity: {avg_complexity:.2f}")
+        output_data(f"Max Complexity: {max_complexity}")

tree_sitter_analyzer/cli/commands/structure_command.py

@@ -7,6 +7,14 @@ Handles structure analysis functionality with appropriate Japanese output.
 
 from typing import TYPE_CHECKING
 
+from ...constants import (
+    ELEMENT_TYPE_CLASS,
+    ELEMENT_TYPE_FUNCTION,
+    ELEMENT_TYPE_IMPORT,
+    ELEMENT_TYPE_PACKAGE,
+    ELEMENT_TYPE_VARIABLE,
+    is_element_of_type,
+)
 from ...output_manager import output_data, output_json, output_section
 from .base_command import BaseCommand
 
@@ -43,19 +51,29 @@ class StructureCommand(BaseCommand):
 
         # Extract elements by type
         classes = [
-            e for e in analysis_result.elements if e.__class__.__name__ == "Class"
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_CLASS)
         ]
         methods = [
-            e for e in analysis_result.elements if e.__class__.__name__ == "Function"
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
         ]
         fields = [
-            e for e in analysis_result.elements if e.__class__.__name__ == "Variable"
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)
         ]
         imports = [
-            e for e in analysis_result.elements if e.__class__.__name__ == "Import"
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_IMPORT)
         ]
         packages = [
-            e for e in analysis_result.elements if e.__class__.__name__ == "Package"
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_PACKAGE)
         ]
 
         return {

tree_sitter_analyzer/cli/commands/summary_command.py

@@ -7,6 +7,13 @@ Handles summary functionality with specified element types.
 
 from typing import TYPE_CHECKING, Any
 
+from ...constants import (
+    ELEMENT_TYPE_CLASS,
+    ELEMENT_TYPE_FUNCTION,
+    ELEMENT_TYPE_IMPORT,
+    ELEMENT_TYPE_VARIABLE,
+    is_element_of_type,
+)
 from ...output_manager import output_data, output_json, output_section
 from .base_command import BaseCommand
 
@@ -38,16 +45,24 @@ class SummaryCommand(BaseCommand):
 
         # Extract elements by type
         classes = [
-            e for e in analysis_result.elements if e.__class__.__name__ == "Class"
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_CLASS)
         ]
         methods = [
-            e for e in analysis_result.elements if e.__class__.__name__ == "Function"
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
         ]
         fields = [
-            e for e in analysis_result.elements if e.__class__.__name__ == "Variable"
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)
         ]
         imports = [
-            e for e in analysis_result.elements if e.__class__.__name__ == "Import"
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_IMPORT)
         ]
 
         summary_data: dict[str, Any] = {

tree_sitter_analyzer/cli/commands/table_command.py

@@ -8,6 +8,14 @@ Handles table format output generation.
 import sys
 from typing import Any
 
+from ...constants import (
+    ELEMENT_TYPE_CLASS,
+    ELEMENT_TYPE_FUNCTION,
+    ELEMENT_TYPE_IMPORT,
+    ELEMENT_TYPE_PACKAGE,
+    ELEMENT_TYPE_VARIABLE,
+    get_element_type,
+)
 from ...output_manager import output_error
 from ...table_formatter import create_table_formatter
 from .base_command import BaseCommand
@@ -58,18 +66,18 @@ class TableCommand(BaseCommand):
         # Process each element
         for i, element in enumerate(analysis_result.elements):
             try:
-                element_type = getattr(element, "__class__", type(element)).__name__
+                element_type = get_element_type(element)
                 element_name = getattr(element, "name", None)
 
-                if element_type == "Package":
+                if element_type == ELEMENT_TYPE_PACKAGE:
                     package_name = str(element_name)
-                elif element_type == "Class":
+                elif element_type == ELEMENT_TYPE_CLASS:
                     classes.append(self._convert_class_element(element, i))
-                elif element_type == "Function":
+                elif element_type == ELEMENT_TYPE_FUNCTION:
                     methods.append(self._convert_function_element(element, language))
-                elif element_type == "Variable":
+                elif element_type == ELEMENT_TYPE_VARIABLE:
                     fields.append(self._convert_variable_element(element, language))
-                elif element_type == "Import":
+                elif element_type == ELEMENT_TYPE_IMPORT:
                     imports.append(self._convert_import_element(element))
 
             except Exception as element_error:

tree_sitter_analyzer/constants.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""
+Constants for tree-sitter-analyzer
+
+This module defines constants used throughout the project to ensure consistency.
+"""
+
+# Element types for unified element management system
+ELEMENT_TYPE_CLASS = "class"
+ELEMENT_TYPE_FUNCTION = "function"
+ELEMENT_TYPE_VARIABLE = "variable"
+ELEMENT_TYPE_IMPORT = "import"
+ELEMENT_TYPE_PACKAGE = "package"
+ELEMENT_TYPE_ANNOTATION = "annotation"
+
+# Element type mapping for backward compatibility
+ELEMENT_TYPE_MAPPING = {
+    "Class": ELEMENT_TYPE_CLASS,
+    "Function": ELEMENT_TYPE_FUNCTION,
+    "Variable": ELEMENT_TYPE_VARIABLE,
+    "Import": ELEMENT_TYPE_IMPORT,
+    "Package": ELEMENT_TYPE_PACKAGE,
+    "Annotation": ELEMENT_TYPE_ANNOTATION,
+}
+
+# Legacy class name to element type mapping
+LEGACY_CLASS_MAPPING = {
+    "Class": ELEMENT_TYPE_CLASS,
+    "Function": ELEMENT_TYPE_FUNCTION,
+    "Variable": ELEMENT_TYPE_VARIABLE,
+    "Import": ELEMENT_TYPE_IMPORT,
+    "Package": ELEMENT_TYPE_PACKAGE,
+    "Annotation": ELEMENT_TYPE_ANNOTATION,
+}
+
+
+def get_element_type(element) -> str:
+    """
+    Get the element type from an element object.
+
+    Args:
+        element: Element object with element_type attribute or __class__.__name__
+
+    Returns:
+        Standardized element type string
+    """
+    if hasattr(element, "element_type"):
+        return element.element_type
+
+    if hasattr(element, "__class__") and hasattr(element.__class__, "__name__"):
+        class_name = element.__class__.__name__
+        return LEGACY_CLASS_MAPPING.get(class_name, "unknown")
+
+    return "unknown"
+
+
+def is_element_of_type(element, element_type: str) -> bool:
+    """
+    Check if an element is of a specific type.
+
+    Args:
+        element: Element object to check
+        element_type: Expected element type
+
+    Returns:
+        True if element is of the specified type
+    """
+    return get_element_type(element) == element_type

tree_sitter_analyzer/core/analysis_engine.py

@@ -560,11 +560,6 @@ class MockLanguagePlugin:
             source_code="// Mock source code",  # 新しいアーキテクチャ用
             language=self.language,  # 言語を設定
             package=None,
-            imports=[],
-            classes=[],
-            methods=[],
-            fields=[],
-            annotations=[],
             analysis_time=0.1,
             success=True,
             error_message=None,

tree_sitter_analyzer/core/engine.py

@@ -200,12 +200,6 @@ class AnalysisEngine:
                 success=True,
                 error_message=None,
                 analysis_time=0.0,
-                # Initialize empty collections for now
-                classes=[],
-                methods=[],
-                fields=[],
-                imports=[],
-                annotations=[],
                 package=None,
             )
 
@@ -458,12 +452,6 @@ class AnalysisEngine:
             source_code="",
             error_message=error,
             analysis_time=0.0,
-            # Initialize empty collections
-            classes=[],
-            methods=[],
-            fields=[],
-            imports=[],
-            annotations=[],
             package=None,
         )
 

tree_sitter_analyzer/interfaces/cli_adapter.py

@@ -150,32 +150,51 @@ class CLIAdapter:
         result = self.analyze_file(file_path, **kwargs)
 
         # 構造情報を辞書形式に変換
+        # Use unified elements system
+        from ..constants import (
+            ELEMENT_TYPE_ANNOTATION,
+            ELEMENT_TYPE_CLASS,
+            ELEMENT_TYPE_FUNCTION,
+            ELEMENT_TYPE_IMPORT,
+            ELEMENT_TYPE_VARIABLE,
+            is_element_of_type,
+        )
+
+        elements = result.elements or []
+
+        # Extract elements by type from unified list
+        imports = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_IMPORT)]
+        classes = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_CLASS)]
+        methods = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)]
+        fields = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)]
+        annotations = [
+            e for e in elements if is_element_of_type(e, ELEMENT_TYPE_ANNOTATION)
+        ]
+
         return {
             "file_path": result.file_path,
             "language": result.language,
             "package": result.package,
             "imports": [
-                {"name": imp.name, "type": str(type(imp).__name__)}
-                for imp in result.imports
+                {"name": imp.name, "type": str(type(imp).__name__)} for imp in imports
             ],
             "classes": [
-                {"name": cls.name, "type": str(type(cls).__name__)}
-                for cls in result.classes
+                {"name": cls.name, "type": str(type(cls).__name__)} for cls in classes
             ],
             "methods": [
                 {"name": method.name, "type": str(type(method).__name__)}
-                for method in result.methods
+                for method in methods
             ],
             "fields": [
                 {"name": field.name, "type": str(type(field).__name__)}
-                for field in result.fields
+                for field in fields
             ],
             "annotations": [
                 {
                     "name": getattr(ann, "name", str(ann)),
                     "type": str(type(ann).__name__),
                 }
-                for ann in getattr(result, "annotations", [])
+                for ann in annotations
             ],
             "analysis_time": result.analysis_time,
             "elements": [
@@ -215,11 +234,7 @@ class CLIAdapter:
                 error_result = AnalysisResult(
                     file_path=file_path,
                     package=None,
-                    imports=[],
-                    classes=[],
-                    methods=[],
-                    fields=[],
-                    annotations=[],
+                    elements=[],
                     analysis_time=0.0,
                     success=False,
                     error_message=str(e),

tree_sitter_analyzer/interfaces/mcp_adapter.py

@@ -67,32 +67,53 @@ class MCPAdapter:
     ) -> dict[str, Any]:
         """Get file structure asynchronously."""
         result = await self.analyze_file_async(file_path, **kwargs)
+        # Use unified elements system
+        from ..constants import (
+            ELEMENT_TYPE_ANNOTATION,
+            ELEMENT_TYPE_CLASS,
+            ELEMENT_TYPE_FUNCTION,
+            ELEMENT_TYPE_IMPORT,
+            ELEMENT_TYPE_VARIABLE,
+            is_element_of_type,
+        )
+
+        elements = result.elements or []
+
+        # Extract elements by type from unified list
+        imports = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_IMPORT)]
+        classes = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_CLASS)]
+        methods = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)]
+        fields = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)]
+        annotations = [
+            e for e in elements if is_element_of_type(e, ELEMENT_TYPE_ANNOTATION)
+        ]
+
         return {
             "file_path": result.file_path,
             "language": result.language,
             "structure": {
                 "classes": [
                     {"name": cls.name, "type": str(type(cls).__name__)}
-                    for cls in result.classes
+                    for cls in classes
                 ],
                 "methods": [
                     {"name": method.name, "type": str(type(method).__name__)}
-                    for method in result.methods
+                    for method in methods
                 ],
                 "fields": [
                     {"name": field.name, "type": str(type(field).__name__)}
-                    for field in result.fields
+                    for field in fields
                 ],
                 "imports": [
                     {"name": imp.name, "type": str(type(imp).__name__)}
-                    for imp in result.imports
+                    for imp in imports
                 ],
                 "annotations": [
                     {
                         "name": getattr(ann, "name", str(ann)),
                         "type": str(type(ann).__name__),
                     }
-                    for ann in getattr(result, "annotations", [])
+                    for ann in annotations
                 ],
             },
             "metadata": {
@@ -100,11 +121,11 @@ class MCPAdapter:
                 "success": result.success,
                 "error_message": result.error_message,
                 "package": result.package,
-                "class_count": len(result.classes),
-                "method_count": len(result.methods),
-                "field_count": len(result.fields),
-                "import_count": len(result.imports),
-                "annotation_count": len(result.annotations),
+                "class_count": len(classes),
+                "method_count": len(methods),
+                "field_count": len(fields),
+                "import_count": len(imports),
+                "annotation_count": len(annotations),
             },
         }
 
@@ -130,11 +151,6 @@ class MCPAdapter:
                     query_results={},
                     source_code="",
                     package=None,
-                    imports=[],
-                    classes=[],
-                    methods=[],
-                    fields=[],
-                    annotations=[],
                     analysis_time=0.0,
                     success=False,
                     error_message=str(e),