index_process.lua

-- Index Process: long-running actor holding the code graph
-- Receives index and query messages from MCP tools
-- Entry kind: process.lua

local logger = require("logger")
local time = require("time")
local index_lib = require("index_lib")
local query_lib = require("query_lib")
local graph_lib = require("graph")

local function reply(dest, topic, data)
    local ok, err = process.send(dest, topic, data)
    if err then
        logger:warn("Failed to reply", {dest = dest, topic = topic, error = tostring(err)})
    end
end

local function reply_error(dest, message)
    reply(dest, "error", {message = message})
end

---------------------------------------------------------------------------
-- Message handlers
---------------------------------------------------------------------------

local function handle_index(state, payload)
    local start = os.clock()
    local result, err = index_lib.index_project(
        state,
        payload.project,
        payload.path
    )

    if err then
        reply_error(payload.reply_to, err)
        return
    end

    result.duration = string.format("%.2fs", os.clock() - start)
    reply(payload.reply_to, "result", result)
end

local function handle_status(state, payload)
    if not state.indexed_at then
        reply(payload.reply_to, "result", {
            indexed = false,
            message = "No project indexed. Run code_index first.",
        })
        return
    end

    local s = graph_lib.stats(state)
    reply(payload.reply_to, "result", {
        indexed = true,
        project = state.project,
        indexed_at = state.indexed_at,
        stats = s,
    })
end

local function handle_query_usages(state, payload)
    if not state.indexed_at then
        reply_error(payload.reply_to, "No project indexed. Run code_index first.")
        return
    end

    local refs, primary = query_lib.find_usages(state, payload.symbol, payload.kind)
    reply(payload.reply_to, "result", {
        symbol = primary and primary.id or payload.symbol,
        symbol_info = primary,
        references = refs,
        count = #refs,
    })
end

local function handle_query_deps(state, payload)
    if not state.indexed_at then
        reply_error(payload.reply_to, "No project indexed. Run code_index first.")
        return
    end

    local tree = query_lib.build_dep_tree(
        state,
        payload.file,
        payload.direction,
        payload.depth
    )
    reply(payload.reply_to, "result", tree)
end

local function handle_query_callers(state, payload)
    if not state.indexed_at then
        reply_error(payload.reply_to, "No project indexed. Run code_index first.")
        return
    end

    local tree = query_lib.find_callers(state, payload.symbol, payload.depth)
    reply(payload.reply_to, "result", tree)
end

local function handle_query_callees(state, payload)
    if not state.indexed_at then
        reply_error(payload.reply_to, "No project indexed. Run code_index first.")
        return
    end

    local tree = query_lib.find_callees(state, payload.symbol, payload.depth)
    reply(payload.reply_to, "result", tree)
end

local function handle_query_hierarchy(state, payload)
    if not state.indexed_at then
        reply_error(payload.reply_to, "No project indexed. Run code_index first.")
        return
    end

    local tree = query_lib.build_hierarchy(state, payload.symbol, payload.direction)
    reply(payload.reply_to, "result", tree)
end

local function handle_query_impacted(state, payload)
    if not state.indexed_at then
        reply_error(payload.reply_to, "No project indexed. Run code_index first.")
        return
    end

    local result = query_lib.find_impacted(state, payload.file, payload.depth)
    reply(payload.reply_to, "result", result)
end

local function handle_query_symbol(state, payload)
    if not state.indexed_at then
        reply_error(payload.reply_to, "No project indexed. Run code_index first.")
        return
    end

    local symbols = graph_lib.find_symbol(state, payload.name, payload.kind)
    reply(payload.reply_to, "result", {
        symbols = symbols,
        count = #symbols,
    })
end

---------------------------------------------------------------------------
-- Topic router
---------------------------------------------------------------------------

local handlers = {
    ["index"]           = handle_index,
    ["index:status"]    = handle_status,
    ["query:usages"]    = handle_query_usages,
    ["query:deps"]      = handle_query_deps,
    ["query:callers"]   = handle_query_callers,
    ["query:callees"]   = handle_query_callees,
    ["query:hierarchy"] = handle_query_hierarchy,
    ["query:impacted"]  = handle_query_impacted,
    ["query:symbol"]    = handle_query_symbol,
}

---------------------------------------------------------------------------
-- Main process loop
---------------------------------------------------------------------------

local function main()
    local state = graph_lib.new_state()

    local ok, reg_err = process.registry.register("code_graph_index")
    if reg_err then
        logger:error("Failed to register", {error = tostring(reg_err)})
        return 1
    end

    logger:info("code_graph_index started", {pid = process.pid()})

    local inbox = process.inbox()
    local events = process.events()

    while true do
        local r = channel.select {
            inbox:case_receive(),
            events:case_receive()
        }

        if r.channel == events then
            local event = r.value
            if event.kind == process.event.CANCEL then
                logger:info("code_graph_index shutting down")
                return 0
            end
        else
            local msg = r.value
            local topic = msg:topic()
            local payload = msg:payload():data() or {}

            local handler = handlers[topic]
            if handler then
                -- Wrap in pcall to prevent crashes from bad queries
                local success, err = pcall(handler, state, payload)
                if not success then
                    logger:error("Handler error", {
                        topic = topic,
                        error = tostring(err),
                    })
                    if payload.reply_to then
                        reply_error(payload.reply_to,
                            "Internal error: " .. tostring(err))
                    end
                end
            else
                logger:warn("Unknown topic", {topic = topic})
                if payload.reply_to then
                    reply_error(payload.reply_to,
                        "Unknown topic: " .. topic)
                end
            end
        end
    end
end

return { main = main }