tree-sitter-analyzer 0.1.0__py3-none-any.whl

tree_sitter_analyzer/queries/python.py

@@ -0,0 +1,286 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Python Tree-sitter queries for code analysis.
+"""
+
+# Function definitions
+FUNCTIONS = """
+(function_definition
+    name: (identifier) @function.name
+    parameters: (parameters) @function.params
+    body: (block) @function.body) @function.definition
+
+(function_definition
+    name: (identifier) @function.name
+    parameters: (parameters) @function.params
+    body: (block) @function.body) @function.async
+"""
+
+# Class definitions
+CLASSES = """
+(class_definition
+    name: (identifier) @class.name
+    superclasses: (argument_list)? @class.superclasses
+    body: (block) @class.body) @class.definition
+"""
+
+# Import statements
+IMPORTS = """
+(import_statement
+    name: (dotted_name) @import.name) @import.statement
+
+(import_from_statement
+    module_name: (dotted_name)? @import.module
+    name: (dotted_name) @import.name) @import.from
+
+(import_from_statement
+    module_name: (dotted_name)? @import.module
+    name: (import_list) @import.list) @import.from_list
+
+(aliased_import
+    name: (dotted_name) @import.name
+    alias: (identifier) @import.alias) @import.aliased
+"""
+
+# Variable assignments
+VARIABLES = """
+(assignment
+    left: (identifier) @variable.name
+    right: (_) @variable.value) @variable.assignment
+
+(assignment
+    left: (pattern_list) @variable.pattern
+    right: (_) @variable.value) @variable.multiple
+
+(augmented_assignment
+    left: (identifier) @variable.name
+    right: (_) @variable.value) @variable.augmented
+"""
+
+# Decorators
+DECORATORS = """
+(decorator
+    (identifier) @decorator.name) @decorator.simple
+
+(decorator
+    (call
+        function: (identifier) @decorator.name
+        arguments: (argument_list) @decorator.args)) @decorator.call
+
+(decorator
+    (attribute
+        object: (identifier) @decorator.object
+        attribute: (identifier) @decorator.name)) @decorator.attribute
+"""
+
+# Method definitions
+METHODS = """
+(function_definition
+    name: (identifier) @method.name
+    parameters: (parameters
+        (identifier) @method.self
+        . (_)*) @method.params
+    body: (block) @method.body) @method.definition
+"""
+
+# Exception handling
+EXCEPTIONS = """
+(try_statement
+    body: (block) @try.body
+    (except_clause
+        type: (_)? @except.type
+        name: (identifier)? @except.name
+        body: (block) @except.body)*
+    (else_clause
+        body: (block) @else.body)?
+    (finally_clause
+        body: (block) @finally.body)?) @try.statement
+
+(raise_statement
+    (call
+        function: (identifier) @exception.name
+        arguments: (argument_list)? @exception.args)) @raise.statement
+"""
+
+# Comprehensions
+COMPREHENSIONS = """
+(list_comprehension
+    body: (_) @comprehension.body
+    (for_in_clause
+        left: (_) @comprehension.var
+        right: (_) @comprehension.iter)) @list.comprehension
+
+(dictionary_comprehension
+    body: (pair
+        key: (_) @comprehension.key
+        value: (_) @comprehension.value)
+    (for_in_clause
+        left: (_) @comprehension.var
+        right: (_) @comprehension.iter)) @dict.comprehension
+
+(set_comprehension
+    body: (_) @comprehension.body
+    (for_in_clause
+        left: (_) @comprehension.var
+        right: (_) @comprehension.iter)) @set.comprehension
+"""
+
+# Comments and docstrings
+COMMENTS = """
+(comment) @comment
+
+(expression_statement
+    (string) @docstring)
+"""
+
+# Type hints and annotations
+TYPE_HINTS = """
+(function_definition
+    parameters: (parameters
+        (typed_parameter
+            type: (_) @type.param)) @type.function_param)
+
+(function_definition
+    return_type: (_) @type.return) @type.function_return
+
+(assignment
+    type: (_) @type.variable) @type.variable_annotation
+"""
+
+# Async/await patterns
+ASYNC_PATTERNS = """
+(function_definition) @async.function
+
+(await
+    (call) @async.await_call) @async.await
+
+(async_for_statement) @async.for
+
+(async_with_statement) @async.with
+"""
+
+# F-strings and string formatting
+STRING_FORMATTING = """
+(formatted_string
+    (interpolation) @string.interpolation) @string.fstring
+
+(call
+    function: (attribute
+        object: (_)
+        attribute: (identifier) @string.format_method))
+"""
+
+# Context managers
+CONTEXT_MANAGERS = """
+(with_statement
+    (with_clause
+        (with_item
+            value: (_) @context.manager)) @context.clause) @context.with
+
+(async_with_statement
+    (with_clause
+        (with_item
+            value: (_) @context.manager)) @context.clause) @context.async_with
+"""
+
+# Lambda expressions
+LAMBDAS = """
+(lambda
+    parameters: (lambda_parameters)? @lambda.params
+    body: (_) @lambda.body) @lambda.expression
+"""
+
+# Modern Python patterns
+MODERN_PATTERNS = """
+(match_statement
+    subject: (_) @match.subject
+    body: (case_clause)+ @match.cases) @pattern.match
+
+(case_clause
+    pattern: (_) @case.pattern
+    guard: (_)? @case.guard
+    consequence: (block) @case.body) @pattern.case
+
+(walrus_operator
+    left: (_) @walrus.target
+    right: (_) @walrus.value) @assignment.walrus
+"""
+
+# All queries combined
+ALL_QUERIES = {
+    "functions": {
+        "query": FUNCTIONS,
+        "description": "すべての関数定義（async含む）を検索",
+    },
+    "classes": {"query": CLASSES, "description": "すべてのクラス定義を検索"},
+    "imports": {"query": IMPORTS, "description": "すべてのインポート文を検索"},
+    "variables": {"query": VARIABLES, "description": "すべての変数代入を検索"},
+    "decorators": {"query": DECORATORS, "description": "すべてのデコレータを検索"},
+    "methods": {
+        "query": METHODS,
+        "description": "クラス内のすべてのメソッド定義を検索",
+    },
+    "exceptions": {
+        "query": EXCEPTIONS,
+        "description": "例外処理とraise文を検索",
+    },
+    "comprehensions": {
+        "query": COMPREHENSIONS,
+        "description": "リスト、辞書、セット内包表記を検索",
+    },
+    "comments": {"query": COMMENTS, "description": "コメントとdocstringを検索"},
+    "type_hints": {
+        "query": TYPE_HINTS,
+        "description": "型ヒントとアノテーションを検索",
+    },
+    "async_patterns": {
+        "query": ASYNC_PATTERNS,
+        "description": "async/awaitパターンを検索",
+    },
+    "string_formatting": {
+        "query": STRING_FORMATTING,
+        "description": "f文字列と文字列フォーマットを検索",
+    },
+    "context_managers": {
+        "query": CONTEXT_MANAGERS,
+        "description": "コンテキストマネージャー（with文）を検索",
+    },
+    "lambdas": {"query": LAMBDAS, "description": "ラムダ式を検索"},
+    "modern_patterns": {
+        "query": MODERN_PATTERNS,
+        "description": "モダンなPythonパターン（match/case、セイウチ演算子）を検索",
+    },
+    # Convenience aliases
+    "function_names": {
+        "query": FUNCTIONS,
+        "description": "関数のエイリアス - すべての関数定義を検索",
+    },
+    "class_names": {
+        "query": CLASSES,
+        "description": "クラスのエイリアス - すべてのクラス定義を検索",
+    },
+    "all_declarations": {
+        "query": FUNCTIONS + "\n\n" + CLASSES + "\n\n" + VARIABLES,
+        "description": "すべての関数、クラス、変数宣言を検索",
+    },
+}
+
+
+def get_query(name: str) -> str:
+    """Get a specific query by name."""
+    if name in ALL_QUERIES:
+        return ALL_QUERIES[name]["query"]
+    raise ValueError(
+        f"Query '{name}' not found. Available queries: {list(ALL_QUERIES.keys())}"
+    )
+
+
+def get_all_queries() -> dict:
+    """Get all available queries."""
+    return ALL_QUERIES
+
+
+def list_queries() -> list:
+    """List all available query names."""
+    return list(ALL_QUERIES.keys())

tree_sitter_analyzer/queries/typescript.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+TypeScript Tree-sitter queries for code analysis.
+"""
+
+# Function declarations and expressions
+FUNCTIONS = """
+(function_declaration
+    name: (identifier) @function.name
+    parameters: (formal_parameters) @function.params
+    return_type: (type_annotation)? @function.return_type
+    body: (statement_block) @function.body) @function.declaration
+
+(function_expression
+    name: (identifier)? @function.name
+    parameters: (formal_parameters) @function.params
+    return_type: (type_annotation)? @function.return_type
+    body: (statement_block) @function.body) @function.expression
+
+(arrow_function
+    parameters: (_) @function.params
+    return_type: (type_annotation)? @function.return_type
+    body: (_) @function.body) @function.arrow
+
+(method_definition
+    name: (_) @function.name
+    parameters: (formal_parameters) @function.params
+    return_type: (type_annotation)? @function.return_type
+    body: (statement_block) @function.body) @method.definition
+"""
+
+# Class declarations
+CLASSES = """
+(class_declaration
+    name: (type_identifier) @class.name
+    type_parameters: (type_parameters)? @class.generics
+    superclass: (class_heritage)? @class.superclass
+    body: (class_body) @class.body) @class.declaration
+
+(abstract_class_declaration
+    name: (type_identifier) @class.name
+    type_parameters: (type_parameters)? @class.generics
+    superclass: (class_heritage)? @class.superclass
+    body: (class_body) @class.body) @class.abstract
+"""
+
+# Interface declarations
+INTERFACES = """
+(interface_declaration
+    name: (type_identifier) @interface.name
+    type_parameters: (type_parameters)? @interface.generics
+    body: (object_type) @interface.body) @interface.declaration
+"""
+
+# Type aliases
+TYPE_ALIASES = """
+(type_alias_declaration
+    name: (type_identifier) @type.name
+    type_parameters: (type_parameters)? @type.generics
+    value: (_) @type.value) @type.alias
+"""
+
+# Enum declarations
+ENUMS = """
+(enum_declaration
+    name: (identifier) @enum.name
+    body: (enum_body) @enum.body) @enum.declaration
+"""
+
+# Variable declarations with types
+VARIABLES = """
+(variable_declaration
+    (variable_declarator
+        name: (identifier) @variable.name
+        type: (type_annotation)? @variable.type
+        value: (_)? @variable.value)) @variable.declaration
+
+(lexical_declaration
+    (variable_declarator
+        name: (identifier) @variable.name
+        type: (type_annotation)? @variable.type
+        value: (_)? @variable.value)) @variable.lexical
+"""
+
+# Import and export statements
+IMPORTS = """
+(import_statement
+    source: (string) @import.source) @import.statement
+
+(import_statement
+    (import_clause
+        (named_imports
+            (import_specifier
+                name: (identifier) @import.name
+                alias: (identifier)? @import.alias))) @import.named
+
+(import_statement
+    (import_clause
+        (import_default_specifier
+            (identifier) @import.default))) @import.default
+
+(import_statement
+    (import_clause
+        (namespace_import
+            (identifier) @import.namespace))) @import.namespace
+
+(type_import
+    (import_clause
+        (named_imports
+            (import_specifier
+                name: (identifier) @import.type.name
+                alias: (identifier)? @import.type.alias)))) @import.type
+"""
+
+EXPORTS = """
+(export_statement
+    declaration: (_) @export.declaration) @export.statement
+
+(export_statement
+    (export_clause
+        (export_specifier
+            name: (identifier) @export.name
+            alias: (identifier)? @export.alias))) @export.named
+"""
+
+# Decorators (TypeScript specific)
+DECORATORS = """
+(decorator
+    (identifier) @decorator.name) @decorator.simple
+
+(decorator
+    (call_expression
+        function: (identifier) @decorator.name
+        arguments: (arguments) @decorator.args)) @decorator.call
+
+(decorator
+    (member_expression
+        object: (identifier) @decorator.object
+        property: (property_identifier) @decorator.name)) @decorator.member
+"""
+
+# Generic type parameters
+GENERICS = """
+(type_parameters
+    (type_parameter
+        name: (type_identifier) @generic.name
+        constraint: (type_annotation)? @generic.constraint
+        default: (type_annotation)? @generic.default)) @generic.parameter
+"""
+
+# Property signatures and method signatures
+SIGNATURES = """
+(property_signature
+    name: (_) @property.name
+    type: (type_annotation) @property.type) @property.signature
+
+(method_signature
+    name: (_) @method.name
+    parameters: (formal_parameters) @method.params
+    return_type: (type_annotation)? @method.return_type) @method.signature
+
+(construct_signature
+    parameters: (formal_parameters) @constructor.params
+    return_type: (type_annotation)? @constructor.return_type) @constructor.signature
+"""
+
+# Comments
+COMMENTS = """
+(comment) @comment
+"""
+
+# All queries combined
+ALL_QUERIES = {
+    "functions": {
+        "query": FUNCTIONS,
+        "description": "型アノテーション付きのすべての関数宣言、式、メソッドを検索",
+    },
+    "classes": {
+        "query": CLASSES,
+        "description": "抽象クラスを含むすべてのクラス宣言を検索",
+    },
+    "interfaces": {
+        "query": INTERFACES,
+        "description": "すべてのインターフェース宣言を検索",
+    },
+    "type_aliases": {
+        "query": TYPE_ALIASES,
+        "description": "すべての型エイリアス宣言を検索",
+    },
+    "enums": {"query": ENUMS, "description": "すべての列挙型宣言を検索"},
+    "variables": {
+        "query": VARIABLES,
+        "description": "型アノテーション付きのすべての変数宣言を検索",
+    },
+    "imports": {
+        "query": IMPORTS,
+        "description": "型インポートを含むすべてのインポート文を検索",
+    },
+    "exports": {"query": EXPORTS, "description": "すべてのエクスポート文を検索"},
+    "decorators": {"query": DECORATORS, "description": "すべてのデコレータを検索"},
+    "generics": {
+        "query": GENERICS,
+        "description": "すべてのジェネリック型パラメータを検索",
+    },
+    "signatures": {
+        "query": SIGNATURES,
+        "description": "プロパティシグネチャ、メソッドシグネチャ、コンストラクタシグネチャを検索",
+    },
+    "comments": {"query": COMMENTS, "description": "すべてのコメントを検索"},
+}
+
+
+def get_query(name: str) -> str:
+    """Get a specific query by name."""
+    if name in ALL_QUERIES:
+        return ALL_QUERIES[name]["query"]
+    raise ValueError(
+        f"Query '{name}' not found. Available queries: {list(ALL_QUERIES.keys())}"
+    )
+
+
+def get_all_queries() -> dict:
+    """Get all available queries."""
+    return ALL_QUERIES
+
+
+def list_queries() -> list:
+    """List all available query names."""
+    return list(ALL_QUERIES.keys())