tree-sitter-analyzer 1.4.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

tree_sitter_analyzer/__init__.py

@@ -11,7 +11,7 @@ Architecture:
 - Data Models: Generic and language-specific code element representations
 """
 
-__version__ = "1.4.1"
+__version__ = "1.6.0"
 __author__ = "aisheng.yu"
 __email__ = "aimasteracc@gmail.com"
 

tree_sitter_analyzer/api.py

@@ -94,8 +94,9 @@ def analyze_file(
 
         # Add elements if requested and available
         if include_elements and hasattr(analysis_result, "elements"):
-            result["elements"] = [
-                {
+            result["elements"] = []
+            for elem in analysis_result.elements:
+                elem_dict = {
                     "name": elem.name,
                     "type": type(elem).__name__.lower(),
                     "start_line": elem.start_line,
@@ -103,8 +104,57 @@ def analyze_file(
                     "raw_text": elem.raw_text,
                     "language": elem.language,
                 }
-                for elem in analysis_result.elements
-            ]
+
+                # Add type-specific fields
+                if hasattr(elem, "module_path"):
+                    elem_dict["module_path"] = elem.module_path
+                if hasattr(elem, "module_name"):
+                    elem_dict["module_name"] = elem.module_name
+                if hasattr(elem, "imported_names"):
+                    elem_dict["imported_names"] = elem.imported_names
+                if hasattr(elem, "variable_type"):
+                    elem_dict["variable_type"] = elem.variable_type
+                if hasattr(elem, "initializer"):
+                    elem_dict["initializer"] = elem.initializer
+                if hasattr(elem, "is_constant"):
+                    elem_dict["is_constant"] = elem.is_constant
+                if hasattr(elem, "parameters"):
+                    elem_dict["parameters"] = elem.parameters
+                if hasattr(elem, "return_type"):
+                    elem_dict["return_type"] = elem.return_type
+                if hasattr(elem, "is_async"):
+                    elem_dict["is_async"] = elem.is_async
+                if hasattr(elem, "is_static"):
+                    elem_dict["is_static"] = elem.is_static
+                if hasattr(elem, "is_constructor"):
+                    elem_dict["is_constructor"] = elem.is_constructor
+                if hasattr(elem, "is_method"):
+                    elem_dict["is_method"] = elem.is_method
+                if hasattr(elem, "complexity_score"):
+                    elem_dict["complexity_score"] = elem.complexity_score
+                if hasattr(elem, "superclass"):
+                    elem_dict["superclass"] = elem.superclass
+                if hasattr(elem, "class_type"):
+                    elem_dict["class_type"] = elem.class_type
+
+                # For methods, try to find the class name from context
+                if elem_dict.get("is_method") and elem_dict["type"] == "function":
+                    # Look for the class this method belongs to
+                    for other_elem in analysis_result.elements:
+                        if (
+                            hasattr(other_elem, "start_line")
+                            and hasattr(other_elem, "end_line")
+                            and type(other_elem).__name__.lower() == "class"
+                            and other_elem.start_line
+                            <= elem.start_line
+                            <= other_elem.end_line
+                        ):
+                            elem_dict["class_name"] = other_elem.name
+                            break
+                    else:
+                        elem_dict["class_name"] = None
+
+                result["elements"].append(elem_dict)
 
         # Add query results if requested and available
         if include_queries and hasattr(analysis_result, "query_results"):
@@ -185,8 +235,9 @@ def analyze_code(
 
         # Add elements if requested and available
         if include_elements and hasattr(analysis_result, "elements"):
-            result["elements"] = [
-                {
+            result["elements"] = []
+            for elem in analysis_result.elements:
+                elem_dict = {
                     "name": elem.name,
                     "type": type(elem).__name__.lower(),
                     "start_line": elem.start_line,
@@ -194,8 +245,57 @@ def analyze_code(
                     "raw_text": elem.raw_text,
                     "language": elem.language,
                 }
-                for elem in analysis_result.elements
-            ]
+
+                # Add type-specific fields
+                if hasattr(elem, "module_path"):
+                    elem_dict["module_path"] = elem.module_path
+                if hasattr(elem, "module_name"):
+                    elem_dict["module_name"] = elem.module_name
+                if hasattr(elem, "imported_names"):
+                    elem_dict["imported_names"] = elem.imported_names
+                if hasattr(elem, "variable_type"):
+                    elem_dict["variable_type"] = elem.variable_type
+                if hasattr(elem, "initializer"):
+                    elem_dict["initializer"] = elem.initializer
+                if hasattr(elem, "is_constant"):
+                    elem_dict["is_constant"] = elem.is_constant
+                if hasattr(elem, "parameters"):
+                    elem_dict["parameters"] = elem.parameters
+                if hasattr(elem, "return_type"):
+                    elem_dict["return_type"] = elem.return_type
+                if hasattr(elem, "is_async"):
+                    elem_dict["is_async"] = elem.is_async
+                if hasattr(elem, "is_static"):
+                    elem_dict["is_static"] = elem.is_static
+                if hasattr(elem, "is_constructor"):
+                    elem_dict["is_constructor"] = elem.is_constructor
+                if hasattr(elem, "is_method"):
+                    elem_dict["is_method"] = elem.is_method
+                if hasattr(elem, "complexity_score"):
+                    elem_dict["complexity_score"] = elem.complexity_score
+                if hasattr(elem, "superclass"):
+                    elem_dict["superclass"] = elem.superclass
+                if hasattr(elem, "class_type"):
+                    elem_dict["class_type"] = elem.class_type
+
+                # For methods, try to find the class name from context
+                if elem_dict.get("is_method") and elem_dict["type"] == "function":
+                    # Look for the class this method belongs to
+                    for other_elem in analysis_result.elements:
+                        if (
+                            hasattr(other_elem, "start_line")
+                            and hasattr(other_elem, "end_line")
+                            and type(other_elem).__name__.lower() == "class"
+                            and other_elem.start_line
+                            <= elem.start_line
+                            <= other_elem.end_line
+                        ):
+                            elem_dict["class_name"] = other_elem.name
+                            break
+                    else:
+                        elem_dict["class_name"] = None
+
+                result["elements"].append(elem_dict)
 
         # Add query results if requested and available
         if include_queries and hasattr(analysis_result, "query_results"):

tree_sitter_analyzer/cli/commands/find_and_grep_cli.py

@@ -57,7 +57,9 @@ def _build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--sort", choices=["path", "mtime", "size"])
 
     # rg options (subset mirrors SearchContent)
-    parser.add_argument("--case", choices=["smart", "insensitive", "sensitive"], default="smart")
+    parser.add_argument(
+        "--case", choices=["smart", "insensitive", "sensitive"], default="smart"
+    )
     parser.add_argument("--fixed-strings", action="store_true")
     parser.add_argument("--word", action="store_true")
     parser.add_argument("--multiline", action="store_true")
@@ -184,4 +186,3 @@ def main() -> None:
 
 if __name__ == "__main__":
     main()
-

tree_sitter_analyzer/cli/commands/list_files_cli.py

@@ -131,4 +131,3 @@ def main() -> None:
 
 if __name__ == "__main__":
     main()
-

tree_sitter_analyzer/cli/commands/search_content_cli.py

@@ -50,7 +50,9 @@ def _build_parser() -> argparse.ArgumentParser:
     )
 
     # rg options
-    parser.add_argument("--case", choices=["smart", "insensitive", "sensitive"], default="smart")
+    parser.add_argument(
+        "--case", choices=["smart", "insensitive", "sensitive"], default="smart"
+    )
     parser.add_argument("--fixed-strings", action="store_true")
     parser.add_argument("--word", action="store_true")
     parser.add_argument("--multiline", action="store_true")
@@ -157,4 +159,3 @@ def main() -> None:
 
 if __name__ == "__main__":
     main()
-

tree_sitter_analyzer/cli_main.py

@@ -152,7 +152,9 @@ def create_argument_parser() -> argparse.ArgumentParser:
         help="Specify output format",
     )
     parser.add_argument(
-        "--table", choices=["full", "compact", "csv"], help="Output in table format"
+        "--table",
+        choices=["full", "compact", "csv", "json"],
+        help="Output in table format",
     )
     parser.add_argument(
         "--include-javadoc",

tree_sitter_analyzer/encoding_utils.py

@@ -72,9 +72,9 @@ class EncodingCache:
             max_size: Maximum number of cached entries
             ttl_seconds: Time-to-live for cache entries in seconds
         """
-        self._cache: dict[
-            str, tuple[str, float]
-        ] = {}  # file_path -> (encoding, timestamp)
+        self._cache: dict[str, tuple[str, float]] = (
+            {}
+        )  # file_path -> (encoding, timestamp)
         self._lock = threading.RLock()
         self._max_size = max_size
         self._ttl_seconds = ttl_seconds

tree_sitter_analyzer/formatters/formatter_factory.py

@@ -5,6 +5,7 @@ Factory for creating language-specific table formatters.
 
 from .base_formatter import BaseTableFormatter
 from .java_formatter import JavaTableFormatter
+from .javascript_formatter import JavaScriptTableFormatter
 from .python_formatter import PythonTableFormatter
 
 
@@ -13,6 +14,8 @@ class TableFormatterFactory:
 
     _formatters: dict[str, type[BaseTableFormatter]] = {
         "java": JavaTableFormatter,
+        "javascript": JavaScriptTableFormatter,
+        "js": JavaScriptTableFormatter,  # Alias
         "python": PythonTableFormatter,
     }