refactor: split out files further

Author: AntoineGS

lua/copilot/api/init.lua

@@ -1,11 +1,12 @@
 local logger = require("copilot.logger")
-local mod = {}
+---@class CopilotApi
+local M = {}
 
 ---@param callback? fun(err: any|nil, data: table, ctx: table): nil
 ---@return any|nil err
 ---@return any data
 ---@return table ctx
-function mod.request(client, method, params, callback)
+function M.request(client, method, params, callback)
   logger.trace("api request:", method, params)
   -- hack to convert empty table to json object,
   -- empty table is convert to json array by default.
@@ -26,7 +27,7 @@ function mod.request(client, method, params, callback)
 end
 
 ---@return boolean sent
-function mod.notify(client, method, params)
+function M.notify(client, method, params)
   logger.trace("api notify:", method, params)
 
   if vim.fn.has("nvim-0.11") == 1 then
@@ -50,15 +51,15 @@ end
 ---@alias copilot_workspace_configurations { settings: copilot_workspace_configuration }
 
 ---@param params copilot_workspace_configurations
-function mod.notify_change_configuration(client, params)
-  return mod.notify(client, "workspace/didChangeConfiguration", params)
+function M.notify_change_configuration(client, params)
+  return M.notify(client, "workspace/didChangeConfiguration", params)
 end
 
 ---@alias copilot_nofify_set_trace_params { value: 'off'|'messages'|'verbose' }
 
 ---@param params copilot_nofify_set_trace_params
-function mod.notify_set_trace(client, params)
-  return mod.notify(client, "$/setTrace", params)
+function M.notify_set_trace(client, params)
+  return M.notify(client, "$/setTrace", params)
 end
 
 ---@alias copilot_check_status_params { options?: { localChecksOnly?: boolean } }
@@ -68,21 +69,21 @@ end
 ---@return any|nil err
 ---@return copilot_check_status_data data
 ---@return table ctx
-function mod.check_status(client, params, callback)
+function M.check_status(client, params, callback)
   if type(params) == "function" then
     callback = params
     params = {}
   end
-  return mod.request(client, "checkStatus", params or {}, callback)
+  return M.request(client, "checkStatus", params or {}, callback)
 end
 
 ---@alias copilot_sign_in_initiate_data { verificationUri?: string, userCode?: string }
 
 ---@return any|nil err
 ---@return copilot_sign_in_initiate_data data
 ---@return table ctx
-function mod.sign_in_initiate(client, callback)
-  return mod.request(client, "signInInitiate", {}, callback)
+function M.sign_in_initiate(client, callback)
+  return M.request(client, "signInInitiate", {}, callback)
 end
 
 ---@alias copilot_sign_in_confirm_params { userId: string }
@@ -92,42 +93,42 @@ end
 ---@return any|nil err
 ---@return copilot_sign_in_confirm_data data
 ---@return table ctx
-function mod.sign_in_confirm(client, params, callback)
-  return mod.request(client, "signInConfirm", params, callback)
+function M.sign_in_confirm(client, params, callback)
+  return M.request(client, "signInConfirm", params, callback)
 end
 
-function mod.sign_out(client, callback)
-  return mod.request(client, "signOut", {}, callback)
+function M.sign_out(client, callback)
+  return M.request(client, "signOut", {}, callback)
 end
 
 ---@alias copilot_get_version_data { version: string }
 
 ---@return any|nil err
 ---@return copilot_get_version_data data
 ---@return table ctx
-function mod.get_version(client, callback)
-  return mod.request(client, "getVersion", {}, callback)
+function M.get_version(client, callback)
+  return M.request(client, "getVersion", {}, callback)
 end
 
 ---@alias copilot_notify_accepted_params { uuid: string, acceptedLength?: integer }
 
 ---@param params copilot_notify_accepted_params
-function mod.notify_accepted(client, params, callback)
-  return mod.request(client, "notifyAccepted", params, callback)
+function M.notify_accepted(client, params, callback)
+  return M.request(client, "notifyAccepted", params, callback)
 end
 
 ---@alias copilot_notify_rejected_params { uuids: string[] }
 
 ---@param params copilot_notify_rejected_params
-function mod.notify_rejected(client, params, callback)
-  return mod.request(client, "notifyRejected", params, callback)
+function M.notify_rejected(client, params, callback)
+  return M.request(client, "notifyRejected", params, callback)
 end
 
 ---@alias copilot_notify_shown_params { uuid: string }
 
 ---@param params copilot_notify_shown_params
-function mod.notify_shown(client, params, callback)
-  return mod.request(client, "notifyShown", params, callback)
+function M.notify_shown(client, params, callback)
+  return M.request(client, "notifyShown", params, callback)
 end
 
 ---@alias copilot_get_completions_data_completion { displayText: string, position: { character: integer, line: integer }, range: { ['end']: { character: integer, line: integer }, start: { character: integer, line: integer } }, text: string, uuid: string }
@@ -136,110 +137,22 @@ end
 ---@return any|nil err
 ---@return copilot_get_completions_data data
 ---@return table ctx
-function mod.get_completions(client, params, callback)
-  return mod.request(client, "getCompletions", params, callback)
+function M.get_completions(client, params, callback)
+  return M.request(client, "getCompletions", params, callback)
 end
 
-function mod.get_completions_cycling(client, params, callback)
-  return mod.request(client, "getCompletionsCycling", params, callback)
+function M.get_completions_cycling(client, params, callback)
+  return M.request(client, "getCompletionsCycling", params, callback)
 end
 
----@alias copilot_panel_solution_data { panelId: string, completionText: string, displayText: string, range: { ['end']: { character: integer, line: integer }, start: { character: integer, line: integer } }, score: number, solutionId: string }
----@alias copilot_panel_on_solution_handler fun(result: copilot_panel_solution_data): nil
----@alias copilot_panel_solutions_done_data { panelId: string, status: 'OK'|'Error', message?: string }
----@alias copilot_panel_on_solutions_done_handler fun(result: copilot_panel_solutions_done_data): nil
-
 ---@return any|nil err
 ---@return integer data
 ---@return table ctx
-function mod.get_panel_completions(client, params, callback)
-  return mod.request(client, "getPanelCompletions", params, callback)
-end
-
-local panel = {
-  callback = {
-    PanelSolution = {},
-    PanelSolutionsDone = {},
-  },
-}
-
-panel.handlers = {
-  ---@param result copilot_panel_solution_data
-  PanelSolution = function(_, result)
-    if panel.callback.PanelSolution[result.panelId] then
-      panel.callback.PanelSolution[result.panelId](result)
-    end
-  end,
-
-  ---@param result copilot_panel_solutions_done_data
-  PanelSolutionsDone = function(_, result)
-    if panel.callback.PanelSolutionsDone[result.panelId] then
-      panel.callback.PanelSolutionsDone[result.panelId](result)
-    end
-  end,
-}
-
----@param panelId string
----@param handlers { on_solution: copilot_panel_on_solution_handler, on_solutions_done: copilot_panel_on_solutions_done_handler }
-function mod.register_panel_handlers(panelId, handlers)
-  assert(type(panelId) == "string", "missing panelId")
-  panel.callback.PanelSolution[panelId] = handlers.on_solution
-  panel.callback.PanelSolutionsDone[panelId] = handlers.on_solutions_done
-end
-
----@param panelId string
-function mod.unregister_panel_handlers(panelId)
-  assert(type(panelId) == "string", "missing panelId")
-  panel.callback.PanelSolution[panelId] = nil
-  panel.callback.PanelSolutionsDone[panelId] = nil
-end
-
----@alias copilot_status_notification_data { status: ''|'Normal'|'InProgress'|'Warning', message: string }
-
-local status = {
-  client_id = nil,
-  ---@type copilot_status_notification_data
-  data = {
-    status = "",
-    message = "",
-  },
-  callback = {},
-}
-
-status.handlers = {
-  ---@param result copilot_status_notification_data
-  ---@param ctx { client_id: integer, method: string }
-  statusNotification = function(_, result, ctx)
-    status.client_id = ctx.client_id
-    status.data = result
-
-    for callback in pairs(status.callback) do
-      callback(status.data)
-    end
-  end,
-}
-
----@param handler fun(data: copilot_status_notification_data): nil
-function mod.register_status_notification_handler(handler)
-  status.callback[handler] = true
-  handler(status.data)
-end
-
----@param handler fun(data: copilot_status_notification_data): nil
-function mod.unregister_status_notification_handler(handler)
-  status.callback[handler] = nil
+function M.get_panel_completions(client, params, callback)
+  return M.request(client, "getPanelCompletions", params, callback)
 end
 
 ---@alias copilot_window_show_document { uri: string, external?: boolean, takeFocus?: boolean, selection?: boolean }
 ---@alias copilot_window_show_document_result { success: boolean }
 
-mod.handlers = {
-  PanelSolution = panel.handlers.PanelSolution,
-  PanelSolutionsDone = panel.handlers.PanelSolutionsDone,
-  statusNotification = status.handlers.statusNotification,
-}
-
-mod.panel = panel
-mod.status = status
-
-return mod
+return M

lua/copilot/client/config.lua

@@ -0,0 +1,156 @@
+local api = require("copilot.api")
+local config = require("copilot.config")
+local util = require("copilot.util")
+local logger = require("copilot.logger")
+local lsp = require("copilot.lsp")
+local utils = require("copilot.client.utils")
+local M = {}
+
+---@param overrides table<string, any>
+---@param client CopilotClient
+function M.prepare_client_config(overrides, client)
+  if lsp.binary.initialization_failed then
+    client.startup_error = "initialization of copilot-language-server failed"
+    return
+  end
+
+  client.startup_error = nil
+
+  local server_path = nil
+  local cmd = nil
+
+  if config.server.custom_server_filepath and vim.fn.filereadable(config.server.custom_server_filepath) then
+    server_path = config.server.custom_server_filepath
+  end
+
+  if config.server.type == "nodejs" then
+    cmd = {
+      lsp.nodejs.node_command,
+      server_path or lsp.nodejs.get_server_path(),
+      "--stdio",
+    }
+  elseif config.server.type == "binary" then
+    cmd = {
+      server_path or lsp.binary.get_server_path(),
+      "--stdio",
+    }
+  end
+
+  if not cmd then
+    logger.error("copilot server type not supported")
+    return
+  end
+
+  local capabilities = vim.lsp.protocol.make_client_capabilities()
+  capabilities.window.showDocument.support = true
+
+  capabilities.workspace = {
+    workspaceFolders = true,
+  }
+
+  local root_dir = utils.get_root_dir(config.root_dir)
+  local workspace_folders = {
+    --- @type workspace_folder
+    {
+      uri = vim.uri_from_fname(root_dir),
+      -- important to keep root_dir as-is for the name as lsp.lua uses this to check the workspace has not changed
+      name = root_dir,
+    },
+  }
+
+  local config_workspace_folders = config.workspace_folders
+
+  for _, config_workspace_folder in ipairs(config_workspace_folders) do
+    if config_workspace_folder ~= "" then
+      table.insert(
+        workspace_folders,
+        --- @type workspace_folder
+        {
+          uri = vim.uri_from_fname(config_workspace_folder),
+          name = config_workspace_folder,
+        }
+      )
+    end
+  end
+
+  local editor_info = util.get_editor_info()
+  local provider_url = config.auth_provider_url
+  local proxy_uri = vim.g.copilot_proxy
+
+  local settings = { ---@type copilot_settings
+    telemetry = { ---@type github_settings_telemetry
+      telemetryLevel = "all",
+    },
+  }
+
+  if proxy_uri then
+    vim.tbl_extend("force", settings, {
+      http = { ---@type copilot_settings_http
+        proxy = proxy_uri,
+        proxyStrictSSL = vim.g.copilot_proxy_strict_ssl or false,
+        proxyKerberosServicePrincipal = nil,
+      },
+    })
+  end
+
+  if provider_url then
+    vim.tbl_extend("force", settings, {
+      ["github-enterprise"] = { ---@type copilot_settings_github-enterprise
+        uri = provider_url,
+      },
+    })
+  end
+
+  -- LSP config, not to be confused with config.lua
+  return vim.tbl_deep_extend("force", {
+    cmd = cmd,
+    root_dir = root_dir,
+    name = "copilot",
+    capabilities = capabilities,
+    get_language_id = function(_, filetype)
+      return require("copilot.client.filetypes").language_for_file_type(filetype)
+    end,
+    on_init = function(lsp_client, initialize_result)
+      if client.id == lsp_client.id then
+        client.capabilities = initialize_result.capabilities
+      end
+
+      vim.schedule(function()
+        local configurations = utils.get_workspace_configurations()
+        api.notify_change_configuration(lsp_client, configurations)
+        logger.trace("workspace configuration", configurations)
+
+        -- to activate tracing if we want it
+        local logger_conf = config.logger
+        local trace_params = { value = logger_conf.trace_lsp } --[[@as copilot_nofify_set_trace_params]]
+        api.notify_set_trace(lsp_client, trace_params)
+
+        -- prevent requests to copilot prior to being initialized
+        client.initialized = true
+      end)
+    end,
+    on_exit = function(code, _, client_id)
+      if client.id == client_id then
+        vim.schedule(function()
+          client.teardown()
+          client.id = nil
+          client.capabilities = nil
+        end)
+      end
+      if code > 0 then
+        vim.schedule(function()
+          require("copilot.command").status()
+        end)
+      end
+    end,
+    handlers = require("copilot.client.handlers").get_handlers(),
+    init_options = {
+      editorInfo = editor_info.editorInfo,
+      editorPluginInfo = editor_info.editorPluginInfo,
+    },
+    settings = settings,
+    workspace_folders = workspace_folders,
+  }, overrides)
+end
+
+return M