queries_lib.lua

-- Language-specific Tree-sitter query patterns for symbol extraction
-- Each language defines patterns for: functions, types, imports, variables
-- Entry kind: library.lua

---------------------------------------------------------------------------
-- Go
---------------------------------------------------------------------------
local go = {
    functions = [[
        (function_declaration
            name: (identifier) @name
        ) @func

        (method_declaration
            receiver: (parameter_list
                (parameter_declaration
                    type: (_) @receiver_type
                )
            )
            name: (field_identifier) @name
        ) @method
    ]],

    types = [[
        (type_declaration
            (type_spec
                name: (type_identifier) @name
                type: (_) @definition
            )
        ) @type_decl
    ]],

    imports = [[
        (import_spec
            name: (package_identifier)? @alias
            path: (interpreted_string_literal) @path
        ) @import
    ]],

    variables = [[
        (var_declaration
            (var_spec
                name: (identifier) @name
            )
        ) @var

        (const_declaration
            (const_spec
                name: (identifier) @name
            )
        ) @const
    ]],
}

---------------------------------------------------------------------------
-- Python
---------------------------------------------------------------------------
local python = {
    functions = [[
        (function_definition
            name: (identifier) @name
            parameters: (parameters) @params
        ) @func

        (decorated_definition
            (function_definition
                name: (identifier) @name
            )
        ) @decorated_func
    ]],

    types = [[
        (class_definition
            name: (identifier) @name
        ) @class
    ]],

    imports = [[
        (import_statement
            name: (dotted_name) @name
        ) @import

        (import_from_statement
            module_name: (dotted_name) @module
            name: (dotted_name) @name
        ) @from_import
    ]],

    variables = [[
        (assignment
            left: (identifier) @name
        ) @assignment
    ]],
}

---------------------------------------------------------------------------
-- JavaScript / TypeScript
---------------------------------------------------------------------------
local javascript = {
    functions = [[
        (function_declaration
            name: (identifier) @name
        ) @func

        (variable_declarator
            name: (identifier) @name
            value: (arrow_function) @arrow
        ) @arrow_func

        (variable_declarator
            name: (identifier) @name
            value: (function_expression) @func_expr
        ) @func_var

        (method_definition
            name: (property_identifier) @name
        ) @method
    ]],

    types = [[
        (class_declaration
            name: (identifier) @name
        ) @class
    ]],

    imports = [[
        (import_statement
            source: (string) @source
        ) @import
    ]],

    variables = [[
        (variable_declarator
            name: (identifier) @name
        ) @var
    ]],

    exports = [[
        (export_statement) @export
    ]],
}

---------------------------------------------------------------------------
-- Lua
---------------------------------------------------------------------------
local lua = {
    functions = [[
        (function_declaration
            name: (_) @name
        ) @func

        (assignment_statement
            (variable_list
                name: (_) @name
            )
            (expression_list
                value: (function_definition) @func_def
            )
        ) @func_assign
    ]],

    variables = [[
        (variable_declaration
            (assignment_statement
                (variable_list
                    name: (identifier) @name
                )
            )
        ) @local_var
    ]],

    imports = [[
        (function_call
            name: (identifier) @func_name
            arguments: (arguments
                (string) @module
            )
            (#match? @func_name "require")
        ) @require
    ]],
}

---------------------------------------------------------------------------
-- PHP
---------------------------------------------------------------------------
local php = {
    functions = [[
        (function_definition
            name: (name) @name
        ) @func

        (method_declaration
            name: (name) @name
        ) @method
    ]],

    types = [[
        (class_declaration
            name: (name) @name
        ) @class

        (interface_declaration
            name: (name) @name
        ) @interface

        (trait_declaration
            name: (name) @name
        ) @trait
    ]],

    imports = [[
        (namespace_use_declaration) @use
    ]],
}

---------------------------------------------------------------------------
-- C#
---------------------------------------------------------------------------
local csharp = {
    functions = [[
        (method_declaration
            name: (identifier) @name
        ) @method
    ]],

    types = [[
        (class_declaration
            name: (identifier) @name
        ) @class

        (interface_declaration
            name: (identifier) @name
        ) @interface

        (struct_declaration
            name: (identifier) @name
        ) @struct

        (enum_declaration
            name: (identifier) @name
        ) @enum
    ]],

    imports = [[
        (using_directive) @using
    ]],
}

---------------------------------------------------------------------------
-- Language registry (map name/alias → patterns)
---------------------------------------------------------------------------

local languages = {
    go         = go,
    javascript = javascript,
    js         = javascript,
    typescript = javascript,
    ts         = javascript,
    tsx        = javascript,
    python     = python,
    py         = python,
    lua        = lua,
    php        = php,
    csharp     = csharp,
    cs         = csharp,
}

--- Get query patterns for a language
-- @param lang string  Language name or alias
-- @return table|nil  Patterns table
local function get_patterns(lang)
    return languages[lang]
end

--- Get canonical language names that have patterns
local function available()
    local seen = {}
    local list = {}
    for name, tbl in pairs(languages) do
        if not seen[tbl] then
            seen[tbl] = true
            table.insert(list, name)
        end
    end
    table.sort(list)
    return list
end

return {
    get_patterns = get_patterns,
    available    = available,
    go           = go,
    python       = python,
    javascript   = javascript,
    lua          = lua,
    php          = php,
    csharp       = csharp,
}