nvim-keymap-migrator 1.0.0

package/src/extractor.js

@@ -0,0 +1,265 @@
+// extraction runtime-first monkey-patch capture with strict-mode fallback
+
+import { spawn } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const START_MARKER = "__NVIM_KEYMAP_MIGRATOR_JSON_START__";
+const END_MARKER = "__NVIM_KEYMAP_MIGRATOR_JSON_END__";
+
+const INJECT_LUA = `
+local user_keymaps = {}
+local warnings = {}
+local original_set = vim.keymap.set
+_G.__nkm_source_ok = nil
+
+local function normalize_modes(mode)
+  if type(mode) == 'table' then
+    return mode
+  end
+  if type(mode) == 'string' then
+    return { mode }
+  end
+  return { 'n' }
+end
+
+local function add_warning(message)
+  table.insert(warnings, tostring(message))
+end
+
+vim.keymap.set = function(mode, lhs, rhs, opts)
+  opts = opts or {}
+  local modes = normalize_modes(mode)
+
+  for _, single_mode in ipairs(modes) do
+    local entry = {
+      mode = single_mode,
+      lhs = lhs,
+      rhs_type = type(rhs),
+      rhs = nil,
+      rhs_source = nil,
+      rhs_what = nil,
+      rhs_name = nil,
+      rhs_line = nil,
+      desc = opts.desc,
+      silent = opts.silent,
+      noremap = opts.noremap,
+      buffer = opts.buffer,
+      nowait = opts.nowait,
+      expr = opts.expr,
+      callback_source = nil,
+    }
+
+    if type(rhs) == 'function' then
+      entry.rhs = '<Lua function>'
+      local info = debug.getinfo(rhs, 'nS')
+      if info then
+        entry.rhs_source = info.source
+        entry.rhs_what = info.what
+        entry.rhs_name = info.name
+        entry.rhs_line = info.linedefined
+        entry.callback_source = info.source
+      end
+    elseif type(rhs) == 'string' then
+      entry.rhs = rhs
+    else
+      entry.rhs = tostring(rhs)
+    end
+
+    table.insert(user_keymaps, entry)
+  end
+
+  return original_set(mode, lhs, rhs, opts)
+end
+
+function _G.__nkm_source_user_config()
+  local config_path = vim.fn.stdpath('config')
+  local init_lua = config_path .. '/init.lua'
+  local init_vim = config_path .. '/init.vim'
+  local source_ok = false
+
+  if vim.fn.filereadable(init_lua) == 1 then
+    local ok, err = pcall(dofile, init_lua)
+    source_ok = ok
+    if not ok then
+      add_warning('failed_to_source_init_lua: ' .. tostring(err))
+    end
+  elseif vim.fn.filereadable(init_vim) == 1 then
+    local ok, err = pcall(vim.cmd, 'source ' .. vim.fn.fnameescape(init_vim))
+    source_ok = ok
+    if not ok then
+      add_warning('failed_to_source_init_vim: ' .. tostring(err))
+    end
+  else
+    add_warning('no_init_file_found')
+  end
+
+  _G.__nkm_source_ok = source_ok
+end
+
+function _G.__nkm_emit_and_quit(mode_label)
+  if vim.v.errmsg and vim.v.errmsg ~= '' then
+    add_warning('vim_errmsg: ' .. tostring(vim.v.errmsg))
+  end
+
+  local payload = {
+    keymaps = user_keymaps,
+    _meta = {
+      leader = vim.g.mapleader or vim.g.maplocalleader or '\\\\',
+      mapleader_set = (vim.g.mapleader ~= nil or vim.g.maplocalleader ~= nil),
+      config_path = vim.fn.stdpath('config'),
+      source_ok = _G.__nkm_source_ok,
+      extraction_mode = mode_label,
+    },
+    _warnings = warnings,
+  }
+
+  io.write('${START_MARKER}\\n')
+  io.write(vim.json.encode(payload))
+  io.write('\\n${END_MARKER}\\n')
+  vim.cmd('qa!')
+end
+`;
+
+export async function extractKeymaps() {
+  const tempDir = await mkdtemp(join(tmpdir(), "nvim-keymap-migrator-"));
+  const scriptPath = join(tempDir, "inject.lua");
+
+  try {
+    await writeFile(scriptPath, INJECT_LUA, "utf8");
+    let runtimeError = null;
+    let payload = null;
+
+    try {
+      payload = await runHeadlessExtraction(scriptPath, tempDir, "runtime");
+    } catch (error) {
+      runtimeError = error;
+    }
+
+    if (!payload) {
+      payload = await runHeadlessExtraction(scriptPath, tempDir, "strict");
+      payload._meta = payload._meta ?? {};
+      payload._meta.fallback_from = "runtime";
+      payload._meta.fallback_reason = summarizeError(runtimeError);
+      payload._warnings = payload._warnings ?? [];
+      payload._warnings.unshift(
+        `runtime_extraction_failed: ${summarizeError(runtimeError)}`,
+      );
+    }
+
+    const keymaps = Array.isArray(payload?.keymaps) ? payload.keymaps : [];
+
+    keymaps._meta = payload?._meta ?? {};
+    keymaps._warnings = payload?._warnings ?? [];
+
+    return keymaps;
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+function runHeadlessExtraction(scriptPath, tempDir, mode) {
+  return new Promise((resolve, reject) => {
+    const logPath = join(tempDir, `nvim-${mode}.log`);
+    const args = ["--headless"];
+
+    if (mode === "strict") {
+      args.push("-u", "NONE");
+    }
+
+    args.push("--cmd", `lua dofile([[${scriptPath}]])`);
+
+    if (mode === "strict") {
+      args.push("-c", "lua _G.__nkm_source_user_config()");
+    }
+
+    args.push("-c", `lua _G.__nkm_emit_and_quit('${mode}')`);
+
+    const nvim = spawn("nvim", args, {
+      env: {
+        ...process.env,
+        NVIM_LOG_FILE: logPath,
+      },
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    nvim.on("error", (err) => {
+      reject(new Error(`Failed to start Neovim process: ${err.message}`));
+    });
+
+    nvim.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    nvim.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    nvim.on("close", (code) => {
+      const combined = `${stdout}\n${stderr}`;
+      let payload = null;
+      try {
+        payload = extractPayload(combined);
+      } catch (error) {
+        reject(
+          new Error(
+            `Failed to parse extraction payload (${mode}): ${error.message}`,
+          ),
+        );
+        return;
+      }
+
+      if (payload !== null) {
+        resolve(payload);
+        return;
+      }
+
+      if (code !== 0) {
+        reject(
+          new Error(
+            `Neovim exited with code ${code}. Output:\n${combined.trim()}`,
+          ),
+        );
+        return;
+      }
+
+      reject(
+        new Error(
+          `Extraction output not found in Neovim stdout/stderr (${mode}).`,
+        ),
+      );
+    });
+  });
+}
+
+function extractPayload(output) {
+  const start = output.indexOf(START_MARKER);
+  const end = output.indexOf(END_MARKER);
+
+  if (start === -1 || end === -1 || end <= start) {
+    return null;
+  }
+
+  const json = output.slice(start + START_MARKER.length, end).trim();
+  if (!json) {
+    return null;
+  }
+
+  return JSON.parse(json);
+}
+
+function summarizeError(error) {
+  if (!error) {
+    return "unknown_runtime_error";
+  }
+
+  const message =
+    typeof error.message === "string" && error.message.trim()
+      ? error.message.trim()
+      : String(error);
+
+  return message.split("\n")[0];
+}

package/src/generators/intellij.js

@@ -0,0 +1,178 @@
+import { loadMappings, lookupIntent } from "../registry.js";
+import { loadDefaults, MODE_TO_MAP, readString, truthy } from "../utils.js";
+
+export function generateIdeaVimrc(keymaps = [], options = {}) {
+  const registry = options.registry ?? loadMappings();
+  const defaults = loadDefaults();
+  const defaultKeymaps = Array.isArray(defaults.keymaps)
+    ? defaults.keymaps
+    : [];
+
+  const userBindings = new Set();
+  for (const keymap of keymaps) {
+    const mode = normalizeMode(keymap.mode);
+    const lhs = readString(keymap.lhs);
+    if (!mode || !lhs) {
+      continue;
+    }
+    userBindings.add(`${mode}|${lhs}`);
+  }
+
+  const defaultLines = [];
+  let defaultsAdded = 0;
+  for (const def of defaultKeymaps) {
+    const mode = normalizeMode(def.mode);
+    const lhs = readString(def.lhs);
+    if (!mode || !lhs) continue;
+    if (userBindings.has(`${mode}|${lhs}`)) {
+      continue;
+    }
+
+    const intent = readString(def.intent);
+    const action = lookupIntent(intent, "intellij", registry);
+    if (!action) continue;
+
+    const mapCmd = pickMapCommand(mode);
+    const line = `${mapCmd} ${def.lhs} <Action>(${action})`;
+    defaultLines.push(line);
+    defaultsAdded += 1;
+  }
+
+  const mapped = [];
+  const pureVimLines = [];
+  const manual = [];
+  const seen = new Set();
+
+  for (const keymap of keymaps) {
+    const lhs = readString(keymap.lhs);
+    const mode = normalizeMode(keymap.mode);
+    const intent = readString(keymap.intent);
+    if (!lhs || !mode) {
+      continue;
+    }
+
+    // no intent - output as pure vim mapping
+    if (!intent) {
+      const opts = readOpts(keymap);
+      const rhs = readRhs(keymap);
+      if (!rhs || rhs === "<Lua function>") {
+        continue;
+      }
+
+      // use nnoremap for all pure vim mappings
+      const mapCmd = "nnoremap";
+      const flags = [];
+      if (truthy(opts.silent)) flags.push("<silent>");
+      if (truthy(opts.expr)) flags.push("<expr>");
+      if (truthy(opts.nowait)) flags.push("<nowait>");
+      if (truthy(opts.buffer)) flags.push("<buffer>");
+
+      const line = `${[mapCmd, ...flags].join(" ")} ${lhs} ${rhs}`;
+      const key = `${mode}|${lhs}|${mapCmd}|${flags.join(",")}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        pureVimLines.push(line);
+      }
+      continue;
+    }
+
+    const action = lookupIntent(intent, "intellij", registry);
+    if (!action) {
+      manual.push({
+        lhs,
+        intent,
+      });
+      continue;
+    }
+
+    const opts = readOpts(keymap);
+    const mapCmd = pickMapCommand(mode, opts.noremap);
+    const flags = [];
+    if (truthy(opts.silent)) flags.push("<silent>");
+    if (truthy(opts.expr)) flags.push("<expr>");
+    if (truthy(opts.nowait)) flags.push("<nowait>");
+    if (truthy(opts.buffer)) flags.push("<buffer>");
+
+    const line = `${[mapCmd, ...flags].join(" ")} ${lhs} <Action>(${action})`;
+    const key = `${mode}|${lhs}|${action}|${mapCmd}|${flags.join(",")}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    mapped.push(line);
+  }
+
+  const lines = [
+    '" Generated by nvim-keymap-migrator',
+    '" IntelliJ IdeaVim action mappings',
+    "",
+  ];
+
+  if (defaultLines.length > 0) {
+    lines.push('" Default LSP keymaps (from Neovim defaults)');
+    lines.push(...defaultLines);
+    lines.push("");
+  }
+
+  if (pureVimLines.length > 0) {
+    lines.push('" Pure Vim mappings (native Vim motions)');
+    lines.push(...pureVimLines);
+    lines.push("");
+  }
+
+  if (mapped.length === 0 && pureVimLines.length === 0) {
+    lines.push('" No IDE-translatable mappings detected.');
+  } else {
+    lines.push(...mapped);
+  }
+
+  lines.push("");
+  lines.push(`" Generated actions: ${defaultLines.length + mapped.length}`);
+  lines.push(`" Pure Vim mappings: ${pureVimLines.length}`);
+  lines.push(`" Manual mappings: ${manual.length}`);
+
+  if (manual.length > 0) {
+    lines.push('" Manual review:');
+    for (const item of manual.slice(0, 20)) {
+      lines.push(`" ${item.lhs} -> ${item.intent}`);
+    }
+  }
+
+  const text = `${lines.join("\n")}\n`;
+  return { text, defaultsAdded };
+}
+
+function normalizeMode(mode) {
+  if (typeof mode !== "string" || !MODE_TO_MAP[mode]) {
+    return null;
+  }
+  return mode;
+}
+
+function pickMapCommand(mode, noremap = false) {
+  const table = MODE_TO_MAP[mode];
+  return noremap ? table.noremap : table.map;
+}
+
+function readRhs(keymap) {
+  const rawRhs = keymap?.raw_rhs;
+  if (typeof rawRhs === "string" && rawRhs.trim()) {
+    return rawRhs.trim();
+  }
+  const rhs = keymap?.rhs;
+  return typeof rhs === "string" ? rhs.trim() : "";
+}
+
+function readOpts(keymap) {
+  if (keymap && keymap.opts && typeof keymap.opts === "object") {
+    return keymap.opts;
+  }
+
+  return {
+    silent: keymap?.silent,
+    noremap: keymap?.noremap ?? false,
+    buffer: keymap?.buffer,
+    nowait: keymap?.nowait,
+    expr: keymap?.expr,
+  };
+}

package/src/generators/vimrc.js

@@ -0,0 +1,118 @@
+import { MODE_TO_MAP, truthy } from "../utils.js";
+
+const EXCLUDED_INTENT_PREFIXES = [
+  "lsp.",
+  "git.",
+  "harpoon.",
+  "todo.",
+  "plugin.",
+];
+
+export function generateVimrc(keymaps = []) {
+  const lines = [
+    '" Generated by nvim-keymap-migrator',
+    '" Shared pure-Vim mappings',
+    "",
+  ];
+
+  let generated = 0;
+  let skipped = 0;
+
+  for (const keymap of keymaps) {
+    const line = toVimMapLine(keymap);
+    if (!line) {
+      skipped += 1;
+      continue;
+    }
+    lines.push(line);
+    generated += 1;
+  }
+
+  if (generated === 0) {
+    lines.push('" No pure Vim-compatible mappings detected.');
+  }
+
+  lines.push("");
+  lines.push(`" Generated mappings: ${generated}`);
+  lines.push(`" Skipped mappings: ${skipped}`);
+
+  return `${lines.join("\n")}\n`;
+}
+
+function toVimMapLine(keymap = {}) {
+  const mode = normalizeMode(keymap.mode);
+  if (!mode) return null;
+
+  const lhs = readField(keymap, "lhs");
+  const rhs = readRhs(keymap);
+  if (!lhs || !rhs || rhs === "<Lua function>") {
+    return null;
+  }
+
+  if (lhs.startsWith("<Plug>") || lhs.startsWith("<plug>")) {
+    return null;
+  }
+
+  const intent = typeof keymap.intent === "string" ? keymap.intent : "";
+  if (shouldExcludeIntent(intent)) {
+    return null;
+  }
+
+  const opts = getOpts(keymap);
+  const mapCmd = pickMapCommand(mode, opts.noremap);
+  const flags = [];
+  if (truthy(opts.silent)) flags.push("<silent>");
+  if (truthy(opts.expr)) flags.push("<expr>");
+  if (truthy(opts.nowait)) flags.push("<nowait>");
+  if (truthy(opts.buffer)) flags.push("<buffer>");
+
+  const prefix = [mapCmd, ...flags].join(" ");
+  return `${prefix} ${lhs} ${rhs}`;
+}
+
+function pickMapCommand(mode, noremap) {
+  const table = MODE_TO_MAP[mode] ?? { noremap: "noremap", map: "map" };
+  return truthy(noremap) ? table.noremap : table.map;
+}
+
+function normalizeMode(mode) {
+  if (typeof mode !== "string") return null;
+  if (mode.length === 0) return null;
+  if (MODE_TO_MAP[mode]) return mode;
+  return null;
+}
+
+function readRhs(keymap) {
+  const rawRhs = readField(keymap, "raw_rhs");
+  if (rawRhs) return rawRhs;
+  return readField(keymap, "rhs");
+}
+
+function readField(obj, name) {
+  if (!obj || typeof obj !== "object") return "";
+  const value = obj[name];
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function getOpts(keymap) {
+  if (keymap && keymap.opts && typeof keymap.opts === "object") {
+    return keymap.opts;
+  }
+
+  return {
+    silent: keymap?.silent,
+    noremap: keymap?.noremap ?? true,
+    buffer: keymap?.buffer,
+    nowait: keymap?.nowait,
+    expr: keymap?.expr,
+  };
+}
+
+function shouldExcludeIntent(intent) {
+  if (!intent) return false;
+  return EXCLUDED_INTENT_PREFIXES.some((prefix) => intent.startsWith(prefix));
+}
+
+export function isPureVimMapping(keymap) {
+  return Boolean(toVimMapLine(keymap));
+}