chore: release 0.1.0 — rename to turbo-debug.nvim

Rename from tiny-debugger to turbo-debug — inspired by Turbo Pascal,
the first IDE with a real visual debugger. This thing isn't tiny,
it's turbo charged.

CHANGELOG for 0.1.0:

Features:
- Zero-config debugging — one line install, everything works
- Modal keybindings (c/s/d/r/q/x/X/D/W/K/E/R/?), active only
  during debug mode, cleanly removed on exit
- Persistent breakpoints via persistent-breakpoints.nvim
- Inline virtual text — variable values in source code
- Hover (K), watch (W), REPL eval (E) from the code window
- Help splash (3s auto-dismiss) + manual help (?)
- Debug mode chrome — winbar indicator, cursor highlight
- dapui integration — controls toolbar, labeled panels
- which-key support — <leader>d debug group auto-registered
- quit_exits_mode option

Adapters (12 languages):
- Python (debugpy + venv detection)
- Rust (codelldb + cargo build + vim.ui.select picker)
- Go (delve), C/C++/Swift (codelldb)
- JavaScript/TypeScript (js-debug-adapter)
- C# (netcoredbg), Java, Kotlin, PHP, Ruby, Lua (osv)

Keybindings:
- <leader>dd — toggle debug mode
- <leader>dx / <leader>dX / <leader>dD — breakpoints (always)
- c s d r C x X D W K E q R ? — modal (debug mode only)

lua/turbo-debug/adapters/c.lua

@@ -0,0 +1,89 @@
+local loader = require("turbo-debug.adapters.init")
+
+local M = {}
+
+local function pick_executable(executables)
+  local co = coroutine.running()
+  if not co then
+    return executables[1]
+  end
+  vim.ui.select(executables, {
+    prompt = "Select executable",
+    format_item = function(path) return vim.fn.fnamemodify(path, ":t") end,
+  }, function(choice)
+    coroutine.resume(co, choice)
+  end)
+  return coroutine.yield()
+end
+
+local function cargo_build_and_pick()
+  vim.notify("cargo build ...")
+  local output = vim.fn.system("cargo build --message-format=json")
+  if vim.v.shell_error ~= 0 then
+    local errors = {}
+    for line in output:gmatch("[^\n]+") do
+      if not line:match("^{") then errors[#errors + 1] = line end
+    end
+    vim.notify("cargo build failed:\n" .. table.concat(errors, "\n"), vim.log.levels.ERROR)
+    return nil
+  end
+
+  local executables = {}
+  for line in output:gmatch("[^\n]+") do
+    local ok, msg = pcall(vim.json.decode, line)
+    if ok and msg.reason == "compiler-artifact" and msg.executable then
+      executables[#executables + 1] = msg.executable
+    end
+  end
+
+  if #executables == 0 then return nil end
+  if #executables == 1 then return executables[1] end
+  return pick_executable(executables)
+end
+
+function M.register(dap)
+  local codelldb = loader.find_executable({ "codelldb" })
+  if not codelldb then return end
+
+  local adapter = {
+    type = "server",
+    port = "${port}",
+    executable = {
+      command = codelldb,
+      args = { "--port", "${port}" },
+    },
+  }
+
+  if not dap.adapters.codelldb then
+    dap.adapters.codelldb = adapter
+  end
+
+  -- C/C++/Swift: pick from compiled executables in cwd
+  local prompt_config = {
+    {
+      type = "codelldb",
+      request = "launch",
+      name = "Launch executable",
+      program = function()
+        return vim.fn.input("Path to executable: ", vim.fn.getcwd() .. "/", "file")
+      end,
+      cwd = "${workspaceFolder}",
+    },
+  }
+  for _, ft in ipairs({ "c", "cpp", "swift" }) do
+    dap.configurations[ft] = dap.configurations[ft] or prompt_config
+  end
+
+  -- Rust: cargo build + picker
+  dap.configurations.rust = dap.configurations.rust or {
+    {
+      type = "codelldb",
+      request = "launch",
+      name = "Cargo build & launch",
+      program = cargo_build_and_pick,
+      cwd = "${workspaceFolder}",
+    },
+  }
+end
+
+return M

lua/turbo-debug/adapters/go.lua

@@ -0,0 +1,32 @@
+local loader = require("turbo-debug.adapters.init")
+
+local M = {}
+
+function M.register(dap)
+  local dlv = loader.find_executable({ "dlv" })
+  if not dlv then return end
+
+  loader.register(dap, "delve", {
+    type = "server",
+    port = "${port}",
+    executable = {
+      command = dlv,
+      args = { "dap", "-l", "127.0.0.1:${port}" },
+    },
+  }, {
+    {
+      type = "delve",
+      request = "launch",
+      name = "Launch file",
+      program = "${file}",
+    },
+    {
+      type = "delve",
+      request = "launch",
+      name = "Launch package",
+      program = "./${relativeFileDirname}",
+    },
+  }, { "go" })
+end
+
+return M

lua/turbo-debug/adapters/init.lua

@@ -0,0 +1,111 @@
+local config = require("turbo-debug.config")
+
+local M = {}
+
+local mason_bin = vim.fn.stdpath("data") .. "/mason/bin/"
+
+function M.find_executable(names)
+  for _, name in ipairs(names) do
+    if vim.fn.executable(name) == 1 then return name end
+    local mason_path = mason_bin .. name
+    if vim.fn.executable(mason_path) == 1 then return mason_path end
+  end
+end
+
+function M.register(dap, name, adapter, configurations, filetypes)
+  if dap.adapters[name] then return end
+  dap.adapters[name] = adapter
+  for _, ft in ipairs(filetypes) do
+    dap.configurations[ft] = dap.configurations[ft] or configurations
+  end
+end
+
+-- simple executable adapters (inlined — no separate files needed)
+local function register_simple_adapters(dap)
+  local simple = {
+    { "netcoredbg", { "netcoredbg" }, {
+      type = "executable", args = { "--interpreter=vscode" },
+    }, { {
+      type = "netcoredbg", request = "launch", name = "Launch .NET",
+      program = function() return vim.fn.input("Path to DLL: ", vim.fn.getcwd() .. "/bin/Debug/", "file") end,
+    } }, { "cs" } },
+
+    { "java", { "java-debug-adapter" }, {
+      type = "executable",
+    }, { {
+      type = "java", request = "launch", name = "Launch class",
+      mainClass = function() return vim.fn.input("Main class: ") end,
+      cwd = "${workspaceFolder}",
+    } }, { "java" } },
+
+    { "kotlin", { "kotlin-debug-adapter" }, {
+      type = "executable",
+    }, { {
+      type = "kotlin", request = "launch", name = "Launch main",
+      mainClass = function() return vim.fn.input("Main class: ") end,
+      projectRoot = "${workspaceFolder}",
+    } }, { "kotlin" } },
+
+    { "php", { "php-debug-adapter" }, {
+      type = "executable",
+    }, { {
+      type = "php", request = "launch", name = "Listen for Xdebug", port = 9003,
+    } }, { "php" } },
+
+    { "rdbg", { "rdbg" }, {
+      type = "server", port = "${port}",
+      executable = { command = nil, args = { "-n", "--open", "--port", "${port}", "-c", "--", "ruby", "${file}" } },
+    }, { {
+      type = "rdbg", request = "launch", name = "Launch file", command = "ruby", script = "${file}",
+    }, {
+      type = "rdbg", request = "attach", name = "Attach", localfsMap = "${workspaceFolder}",
+    } }, { "ruby" } },
+  }
+
+  for _, s in ipairs(simple) do
+    local name, exe_names, adapter_tpl, configurations, filetypes = s[1], s[2], s[3], s[4], s[5]
+    local exe = M.find_executable(exe_names)
+    if exe then
+      local adapter = vim.deepcopy(adapter_tpl)
+      adapter.command = adapter.command or exe
+      if adapter.executable then adapter.executable.command = exe end
+      M.register(dap, name, adapter, configurations, filetypes)
+    end
+  end
+
+  -- lua/neovim (osv) — optional, skip if not installed
+  local ok, osv = pcall(require, "osv")
+  if ok then
+    M.register(dap, "nlua", {
+      type = "server", host = "127.0.0.1",
+      port = function() return osv.launch({ port = 0 }) end,
+    }, { {
+      type = "nlua", request = "attach", name = "Attach to running Neovim",
+    } }, { "lua" })
+  end
+end
+
+function M.setup()
+  if not config.opts.builtin_adapters then return end
+
+  local dap = require("dap")
+
+  -- load adapters with non-trivial logic from separate files
+  for _, name in ipairs({ "python", "go", "c", "javascript" }) do
+    local ok, adapter_mod = pcall(require, "turbo-debug.adapters." .. name)
+    if ok and adapter_mod.register then
+      adapter_mod.register(dap)
+    end
+  end
+
+  -- register simple adapters inlined above
+  register_simple_adapters(dap)
+
+  -- apply user adapter overrides (last — wins over everything)
+  for name, adapter_config in pairs(config.opts.adapters) do
+    if adapter_config.adapter then dap.adapters[name] = adapter_config.adapter end
+    if adapter_config.configurations then dap.configurations[name] = adapter_config.configurations end
+  end
+end
+
+return M

lua/turbo-debug/adapters/javascript.lua

@@ -0,0 +1,42 @@
+local loader = require("turbo-debug.adapters.init")
+
+local M = {}
+
+function M.register(dap)
+  local js_debug = loader.find_executable({ "js-debug-adapter" })
+  if not js_debug then return end
+
+  local adapter = {
+    type = "server",
+    port = "${port}",
+    executable = {
+      command = js_debug,
+      args = { "${port}" },
+    },
+  }
+
+  local configurations = {
+    {
+      type = "pwa-node",
+      request = "launch",
+      name = "Launch file",
+      program = "${file}",
+      cwd = "${workspaceFolder}",
+    },
+    {
+      type = "pwa-node",
+      request = "attach",
+      name = "Attach",
+      processId = function()
+        return require("dap.utils").pick_process()
+      end,
+      cwd = "${workspaceFolder}",
+    },
+  }
+
+  loader.register(dap, "pwa-node", adapter, configurations, {
+    "javascript", "typescript", "javascriptreact", "typescriptreact",
+  })
+end
+
+return M

lua/turbo-debug/adapters/python.lua

@@ -0,0 +1,52 @@
+local loader = require("turbo-debug.adapters.init")
+
+local M = {}
+
+local function find_python()
+  -- check active virtualenv
+  local venv = vim.env.VIRTUAL_ENV
+  if venv then
+    local path = venv .. "/bin/python"
+    if vim.fn.executable(path) == 1 then return path end
+  end
+
+  -- check conda
+  local conda = vim.env.CONDA_PREFIX
+  if conda then
+    local path = conda .. "/bin/python"
+    if vim.fn.executable(path) == 1 then return path end
+  end
+
+  -- probe common venv directories relative to cwd
+  local cwd = vim.fn.getcwd()
+  for _, dir in ipairs({ ".venv", "venv", "env", ".env" }) do
+    local path = cwd .. "/" .. dir .. "/bin/python"
+    if vim.fn.executable(path) == 1 then return path end
+  end
+
+  -- fallback to system python
+  if vim.fn.executable("python3") == 1 then return "python3" end
+  if vim.fn.executable("python") == 1 then return "python" end
+  return nil
+end
+
+function M.register(dap)
+  local python = find_python()
+  if not python then return end
+
+  loader.register(dap, "debugpy", {
+    type = "executable",
+    command = python,
+    args = { "-m", "debugpy.adapter" },
+  }, {
+    {
+      type = "debugpy",
+      request = "launch",
+      name = "Launch file",
+      program = "${file}",
+      pythonPath = function() return find_python() end,
+    },
+  }, { "python" })
+end
+
+return M