code_outline.lua

-- MCP Tool: code_outline
-- Generate a structural outline: functions, types, imports, variables
-- Uses language-specific Tree-sitter queries for accurate extraction
-- Entry kind: function.lua

local json = require("json")
local treesitter = require("treesitter")
local parser = require("parser")
local queries = require("queries")

--- Run a query pattern safely, returning captures or empty table
local function safe_captures(lang, pattern, root, code)
    if not pattern then return {} end
    local query, err = treesitter.query(lang, pattern)
    if err then return {} end
    local captures = query:captures(root, code)
    return captures or {}
end

--- Group captures by their @name
local function group_captures(captures)
    local groups = {}
    for _, cap in ipairs(captures) do
        if not groups[cap.name] then
            groups[cap.name] = {}
        end
        table.insert(groups[cap.name], cap)
    end
    return groups
end

--- Build a section from captures, deduplicating by text
local function build_section(title, captures)
    if not captures or #captures == 0 then return nil end

    local items = {}
    local seen = {}
    for _, cap in ipairs(captures) do
        local text = cap.text
        if text and not seen[text] then
            seen[text] = true
            local pos = parser.node_pos(cap.node)
            table.insert(items, {
                name = text,
                line = pos.start_line,
                end_line = pos.end_line,
            })
        end
    end

    if #items == 0 then return nil end
    return { title = title, count = #items, items = items }
end

--- Fallback: list top-level named children
local function fallback_outline(root)
    local children = {}
    local count = root:child_count()
    for i = 0, count - 1 do
        local child = root:child(i)
        if child and child:is_named() then
            local pos = parser.node_pos(child)
            local text = child:text()
            if #text > 80 then text = string.sub(text, 1, 77) .. "..." end
            table.insert(children, {
                kind = child:kind(),
                line = pos.start_line,
                text = text,
            })
        end
    end
    if #children == 0 then return nil end
    return { title = "Top-level nodes", count = #children, items = children }
end

local function call(arguments)
    local code, lang, err = parser.resolve_source(arguments)
    if err then return "Error: " .. err end

    local tree, root, parse_err = parser.parse(lang, code)
    if parse_err then return "Error: " .. parse_err end

    local patterns = queries.get_patterns(lang)
    local sections = {}

    if patterns then
        -- Functions & Methods
        local fcaps = safe_captures(lang, patterns.functions, root, code)
        local fgroups = group_captures(fcaps)
        local fsec = build_section("Functions", fgroups["name"])
        if fsec then table.insert(sections, fsec) end

        -- Types / Classes
        local tcaps = safe_captures(lang, patterns.types, root, code)
        local tgroups = group_captures(tcaps)
        local tsec = build_section("Types", tgroups["name"])
        if tsec then table.insert(sections, tsec) end

        -- Imports
        local icaps = safe_captures(lang, patterns.imports, root, code)
        local igroups = group_captures(icaps)
        local isec = build_section("Imports",
            igroups["path"] or igroups["name"]
            or igroups["module"] or igroups["source"])
        if isec then table.insert(sections, isec) end

        -- Variables / Constants
        local vcaps = safe_captures(lang, patterns.variables, root, code)
        local vgroups = group_captures(vcaps)
        local vsec = build_section("Variables", vgroups["name"])
        if vsec then table.insert(sections, vsec) end

        -- Exports (JS/TS only)
        if patterns.exports then
            local ecaps = safe_captures(lang, patterns.exports, root, code)
            local egroups = group_captures(ecaps)
            local esec = build_section("Exports", egroups["export"])
            if esec then table.insert(sections, esec) end
        end
    else
        -- No language-specific patterns — fallback
        local fb = fallback_outline(root)
        if fb then table.insert(sections, fb) end
    end

    -- Format output
    local lines = {}
    table.insert(lines, "# Code Outline (" .. lang .. ")")
    if parser.has_errors(root) then
        table.insert(lines, "⚠ Source contains syntax errors")
    end
    table.insert(lines, "")

    if #sections == 0 then
        table.insert(lines, "No symbols found.")
    end

    for _, section in ipairs(sections) do
        table.insert(lines, "## " .. section.title .. " (" .. section.count .. ")")
        for _, item in ipairs(section.items) do
            local name = item.name or item.text or item.kind
            if #name > 100 then name = string.sub(name, 1, 97) .. "..." end
            local range = ""
            if item.end_line and item.end_line ~= item.line then
                range = string.format("L%d-%d", item.line, item.end_line)
            else
                range = string.format("L%d", item.line)
            end
            table.insert(lines, string.format("  %-10s %s", range, name))
        end
        table.insert(lines, "")
    end

    return table.concat(lines, "\n")
end

return { call = call }