nvim-keymap-migrator 1.0.0

package/src/generators/vscode.js

@@ -0,0 +1,175 @@
+import { loadMappings, lookupIntent } from "../registry.js";
+import { loadDefaults, readString } from "../utils.js";
+
+export const MANAGED_BY_MARKER = "nvim-keymap-migrator";
+
+const MODE_TO_SECTION = {
+  n: "vim.normalModeKeyBindings",
+  v: "vim.visualModeKeyBindings",
+  x: "vim.visualModeKeyBindings",
+  s: "vim.visualModeKeyBindings",
+  i: "vim.insertModeKeyBindings",
+};
+
+export const VIM_KEYBINDING_SECTIONS = [
+  "vim.normalModeKeyBindings",
+  "vim.visualModeKeyBindings",
+  "vim.insertModeKeyBindings",
+];
+
+export function generateVSCodeBindings(keymaps = [], options = {}) {
+  const registry = options.registry ?? loadMappings();
+  const defaults = loadDefaults();
+  const defaultKeymaps = Array.isArray(defaults.keymaps)
+    ? defaults.keymaps
+    : [];
+  let defaultsAdded = 0;
+  const sections = {
+    "vim.normalModeKeyBindings": [],
+    "vim.visualModeKeyBindings": [],
+    "vim.insertModeKeyBindings": [],
+  };
+
+  const userBindings = new Set();
+  for (const keymap of keymaps) {
+    const intent = readString(keymap.intent);
+    if (intent) {
+      const mode = normalizeMode(keymap.mode);
+      const lhs = readString(keymap.lhs);
+      if (mode && lhs) {
+        userBindings.add(`${mode}|${lhs}`);
+      }
+    }
+  }
+
+  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 command = lookupIntent(intent, "vscode", registry);
+    if (!command) continue;
+
+    const before = toBeforeTokens(lhs);
+    if (before.length === 0) continue;
+
+    const section = MODE_TO_SECTION[mode];
+    sections[section].push({
+      before,
+      commands: [command],
+      _managedBy: MANAGED_BY_MARKER,
+    });
+    defaultsAdded += 1;
+  }
+
+  const seen = new Set();
+  const manual = [];
+
+  for (const keymap of keymaps) {
+    const intent = readString(keymap.intent);
+    const lhs = readString(keymap.lhs);
+    const mode = normalizeMode(keymap.mode);
+    if (!intent || !lhs || !mode) {
+      continue;
+    }
+
+    const command = lookupIntent(intent, "vscode", registry);
+    if (!command) {
+      manual.push({ lhs, intent });
+      continue;
+    }
+
+    const before = toBeforeTokens(lhs);
+    if (before.length === 0) {
+      manual.push({ lhs, intent });
+      continue;
+    }
+
+    const section = MODE_TO_SECTION[mode];
+    const entryKey = `${section}|${before.join(",")}|${command}`;
+    if (seen.has(entryKey)) {
+      continue;
+    }
+    seen.add(entryKey);
+
+    sections[section].push({
+      before,
+      commands: [command],
+      _managedBy: MANAGED_BY_MARKER,
+    });
+  }
+
+  return {
+    ...sections,
+    _meta: {
+      generated: Object.values(sections).reduce(
+        (sum, list) => sum + list.length,
+        0,
+      ),
+      defaultsAdded,
+      manual: manual.length,
+      manual_examples: manual.slice(0, 20),
+    },
+  };
+}
+
+function normalizeMode(mode) {
+  if (typeof mode !== "string" || !MODE_TO_SECTION[mode]) {
+    return null;
+  }
+  return mode;
+}
+
+function toBeforeTokens(lhs) {
+  const tokens = [];
+  let i = 0;
+
+  while (i < lhs.length) {
+    const ch = lhs[i];
+    if (ch === "<") {
+      const end = lhs.indexOf(">", i + 1);
+      if (end === -1) {
+        return [];
+      }
+      const token = lhs.slice(i + 1, end).trim();
+      const mapped = mapSpecialToken(token);
+      if (!mapped) {
+        return [];
+      }
+      tokens.push(mapped);
+      i = end + 1;
+      continue;
+    }
+
+    tokens.push(ch);
+    i += 1;
+  }
+
+  return tokens.filter(Boolean);
+}
+
+function mapSpecialToken(token) {
+  const raw = token.toLowerCase();
+  if (raw === "leader") return "<leader>";
+  if (raw === "cr" || raw === "enter" || raw === "return") return "enter";
+  if (raw === "esc" || raw === "escape") return "escape";
+  if (raw === "tab") return "tab";
+  if (raw === "space") return "<space>";
+  if (raw === "bs" || raw === "backspace") return "backspace";
+  if (raw === "lt") return "<";
+
+  const ctrl = raw.match(/^c-(.)$/);
+  if (ctrl) return `ctrl+${ctrl[1]}`;
+
+  const shift = raw.match(/^s-(.)$/);
+  if (shift) return `shift+${shift[1]}`;
+
+  const alt = raw.match(/^a-(.)$/);
+  if (alt) return `alt+${alt[1]}`;
+
+  return raw;
+}

package/src/install.js

@@ -0,0 +1,379 @@
+import { readFile, writeFile, access, mkdir, rename } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+import {
+  ensureNamespaceDir,
+  readMetadata,
+  writeMetadata,
+} from "./namespace.js";
+import {
+  MANAGED_BY_MARKER,
+  VIM_KEYBINDING_SECTIONS,
+} from "./generators/vscode.js";
+
+const MARKER_START = '" <<< nvim-keymap-migrator start >>>';
+const MARKER_END = '" >>> nvim-keymap-migrator end <<<';
+
+function leaderToVSCodeFormat(leader) {
+  if (leader === " ") return "<space>";
+  if (leader === "\t") return "<tab>";
+  if (leader === "\\") return "\\";
+  if (leader === "\n") return "<cr>";
+  if (leader === "\r") return "<cr>";
+  return leader;
+}
+
+function leaderToIdeaVimFormat(leader) {
+  if (leader === " ") return "\\<space>";
+  if (leader === "\t") return "\\<tab>";
+  if (leader === "\\") return "\\\\";
+  if (leader === "\n") return "\\<cr>";
+  if (leader === "\r") return "\\<cr>";
+  if (leader.includes("<")) {
+    return leader.replace(/</g, "\\<");
+  }
+  return leader;
+}
+
+function getIdeaVimrcPath() {
+  return join(homedir(), ".ideavimrc");
+}
+
+function getVSCodeSettingsPath() {
+  const p = platform();
+
+  if (p === "darwin") {
+    return join(
+      homedir(),
+      "Library/Application Support/Code/User/settings.json",
+    );
+  }
+
+  if (p === "win32") {
+    const appData = process.env.APPDATA;
+    if (appData) {
+      return join(appData, "Code/User/settings.json");
+    }
+  }
+
+  return join(homedir(), ".config/Code/User/settings.json");
+}
+
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readTextFile(path, fallback = "") {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return fallback;
+  }
+}
+
+async function readJsonFile(path, fallback = {}) {
+  try {
+    const content = await readFile(path, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return fallback;
+  }
+}
+
+async function ensureDirForFile(filePath) {
+  const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+  if (dir) {
+    await mkdir(dir, { recursive: true });
+  }
+}
+
+async function writeJsonAtomic(path, data) {
+  const dir = path.substring(0, path.lastIndexOf("/"));
+  const tempPath = join(dir, `.nkm-temp-${Date.now()}.json`);
+  await writeFile(tempPath, JSON.stringify(data, null, 2), "utf8");
+  await rename(tempPath, path);
+}
+
+function extractManagedBlock(content) {
+  const startIdx = content.indexOf(MARKER_START);
+  const endIdx = content.indexOf(MARKER_END);
+
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
+    return { before: content, block: null, after: "" };
+  }
+
+  const before = content.slice(0, startIdx);
+  const block = content.slice(startIdx, endIdx + MARKER_END.length);
+  const after = content.slice(endIdx + MARKER_END.length);
+
+  return { before, block, after };
+}
+
+function buildManagedBlock(mappings, leader) {
+  const leaderLine = leader
+    ? `let mapleader = "${leaderToIdeaVimFormat(leader)}"`
+    : "";
+  const leaderSection = leaderLine ? `${leaderLine}\n\n` : "";
+
+  return `${MARKER_START}
+" Managed by nvim-keymap-migrator. Run with --clean to remove.
+${leaderSection}${mappings}
+${MARKER_END}`;
+}
+
+async function integrateIdeaVim(mappings, options = {}) {
+  const vimrcPath = getIdeaVimrcPath();
+  const content = await readTextFile(vimrcPath, "");
+  const { before, block, after } = extractManagedBlock(content);
+
+  const managedBlock = buildManagedBlock(mappings, options.leader);
+
+  if (block) {
+    const newContent = before + managedBlock + after;
+    await writeFile(vimrcPath, newContent, "utf8");
+    return { integrated: true, updated: true };
+  }
+
+  const newContent = content.trim()
+    ? `${content.trim()}\n\n${managedBlock}\n`
+    : `${managedBlock}\n`;
+
+  await writeFile(vimrcPath, newContent, "utf8");
+  return { integrated: true, updated: false };
+}
+
+async function cleanIdeaVim() {
+  const vimrcPath = getIdeaVimrcPath();
+  const exists = await fileExists(vimrcPath);
+
+  if (!exists) {
+    return { cleaned: true, reason: "no_file" };
+  }
+
+  const content = await readTextFile(vimrcPath, "");
+  const { before, block, after } = extractManagedBlock(content);
+
+  if (!block) {
+    return { cleaned: false, reason: "no_block" };
+  }
+
+  const cleaned = (before + after).trim();
+  if (cleaned) {
+    await writeFile(vimrcPath, cleaned + "\n", "utf8");
+  } else {
+    await writeFile(vimrcPath, "", "utf8");
+  }
+
+  return { cleaned: true, reason: "removed_block" };
+}
+
+async function integrateVSCode(bindings, options = {}) {
+  const settingsPath = getVSCodeSettingsPath();
+  await ensureDirForFile(settingsPath);
+
+  const existing = await readJsonFile(settingsPath, {});
+  const warnings = [];
+  const sectionsModified = [];
+  let setLeader = false;
+
+  const leader = options.leader ? leaderToVSCodeFormat(options.leader) : null;
+  const vimrcPath = "~/.config/nvim-keymap-migrator/.vimrc";
+  let setVimrcPath = false;
+
+  if (leader && existing["vim.leader"] === undefined) {
+    existing["vim.leader"] = leader;
+    setLeader = true;
+  } else if (leader && existing["vim.leader"] !== leader) {
+    warnings.push(
+      `vim.leader already set to "${existing["vim.leader"]}" (ours: "${leader}"), keeping existing`,
+    );
+  }
+
+  if (existing["vim.vimrc.path"] === undefined) {
+    existing["vim.vimrc.path"] = vimrcPath;
+    setVimrcPath = true;
+  } else if (existing["vim.vimrc.path"] !== vimrcPath) {
+    warnings.push(
+      `vim.vimrc.path already set to "${existing["vim.vimrc.path"]}" (ours: "${vimrcPath}"), keeping existing`,
+    );
+  }
+
+  let setVimrcEnable = false;
+  if (existing["vim.vimrc.enable"] === undefined) {
+    existing["vim.vimrc.enable"] = true;
+    setVimrcEnable = true;
+  } else if (existing["vim.vimrc.enable"] !== true) {
+    warnings.push(
+      `vim.vimrc.enable is "${existing["vim.vimrc.enable"]}" (expected true), keeping existing`,
+    );
+  }
+
+  for (const section of VIM_KEYBINDING_SECTIONS) {
+    const newBindings = bindings[section];
+    if (!Array.isArray(newBindings) || newBindings.length === 0) {
+      continue;
+    }
+
+    const existingBindings = Array.isArray(existing[section])
+      ? existing[section]
+      : [];
+
+    const existingManaged = existingBindings.filter(
+      (e) => e._managedBy === MANAGED_BY_MARKER,
+    );
+    const existingUnmanaged = existingBindings.filter(
+      (e) => e._managedBy !== MANAGED_BY_MARKER,
+    );
+
+    if (existingManaged.length > 0) {
+      warnings.push(
+        `${section}: replacing ${existingManaged.length} previously managed binding(s)`,
+      );
+    }
+
+    existing[section] = [...existingUnmanaged, ...newBindings];
+    sectionsModified.push(section);
+  }
+
+  await writeJsonAtomic(settingsPath, existing);
+
+  return {
+    integrated: true,
+    sections: sectionsModified,
+    warnings: warnings.length > 0 ? warnings : undefined,
+    setLeader,
+    setVimrcPath,
+    setVimrcEnable,
+  };
+}
+
+async function cleanVSCode() {
+  const settingsPath = getVSCodeSettingsPath();
+  const exists = await fileExists(settingsPath);
+
+  if (!exists) {
+    return { cleaned: true, reason: "no_file" };
+  }
+
+  const existing = await readJsonFile(settingsPath, null);
+
+  if (!existing || typeof existing !== "object") {
+    return { cleaned: false, reason: "invalid_json" };
+  }
+
+  let totalRemoved = 0;
+  const sectionsCleaned = [];
+  let removedLeader = false;
+  let removedVimrcPath = false;
+  let removedVimrcEnable = false;
+
+  const metadata = await readMetadata();
+  if (metadata?.leader_set && existing["vim.leader"] !== undefined) {
+    delete existing["vim.leader"];
+    removedLeader = true;
+  }
+
+  if (metadata?.vimrc_path_set && existing["vim.vimrc.path"] !== undefined) {
+    delete existing["vim.vimrc.path"];
+    removedVimrcPath = true;
+  }
+
+  if (
+    metadata?.vimrc_enable_set &&
+    existing["vim.vimrc.enable"] !== undefined
+  ) {
+    delete existing["vim.vimrc.enable"];
+    removedVimrcEnable = true;
+  }
+
+  for (const section of VIM_KEYBINDING_SECTIONS) {
+    if (!Array.isArray(existing[section])) {
+      continue;
+    }
+
+    const before = existing[section].length;
+    existing[section] = existing[section].filter(
+      (entry) => entry._managedBy !== MANAGED_BY_MARKER,
+    );
+    const after = existing[section].length;
+
+    if (before !== after) {
+      totalRemoved += before - after;
+      sectionsCleaned.push(section);
+    }
+
+    if (existing[section].length === 0) {
+      delete existing[section];
+    }
+  }
+
+  if (
+    totalRemoved === 0 &&
+    !removedLeader &&
+    !removedVimrcPath &&
+    !removedVimrcEnable
+  ) {
+    return { cleaned: false, reason: "no_managed_bindings" };
+  }
+
+  await writeJsonAtomic(settingsPath, existing);
+
+  return {
+    cleaned: true,
+    reason: "removed_bindings",
+    removed: totalRemoved,
+    sections: sectionsCleaned.length > 0 ? sectionsCleaned : undefined,
+    removedLeader,
+    removedVimrcPath,
+    removedVimrcEnable,
+  };
+}
+
+async function saveMetadata(config, counts, options = {}) {
+  await ensureNamespaceDir();
+
+  const existing = await readMetadata();
+
+  const metadata = existing
+    ? {
+        version: 1,
+        created_at: existing.created_at,
+        updated_at: new Date().toISOString(),
+        leader: config.leader ?? "\\",
+        leader_set: options.leaderSet ?? existing.leader_set ?? false,
+        vimrc_path_set:
+          options.vimrcPathSet ?? existing.vimrc_path_set ?? false,
+        vimrc_enable_set:
+          options.vimrcEnableSet ?? existing.vimrc_enable_set ?? false,
+        config_path: config.config_path ?? null,
+        counts,
+      }
+    : {
+        version: 1,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        leader: config.leader ?? "\\",
+        leader_set: options.leaderSet ?? false,
+        vimrc_path_set: options.vimrcPathSet ?? false,
+        vimrc_enable_set: options.vimrcEnableSet ?? false,
+        config_path: config.config_path ?? null,
+        counts,
+      };
+
+  await writeMetadata(metadata);
+}
+
+export {
+  integrateIdeaVim,
+  cleanIdeaVim,
+  integrateVSCode,
+  cleanVSCode,
+  saveMetadata,
+  getIdeaVimrcPath,
+  getVSCodeSettingsPath,
+};

package/src/namespace.js

@@ -0,0 +1,63 @@
+import { mkdir, readFile, writeFile, access, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const NAMESPACE_DIR = ".config/nvim-keymap-migrator";
+const METADATA_FILE = "metadata.json";
+
+function getNamespaceDir() {
+  return join(homedir(), NAMESPACE_DIR);
+}
+
+function getMetadataPath() {
+  return join(getNamespaceDir(), METADATA_FILE);
+}
+
+function getRcPath(editor) {
+  if (editor === "neovim") {
+    return join(getNamespaceDir(), ".vimrc");
+  }
+  return join(getNamespaceDir(), `${editor}.rc`);
+}
+
+async function ensureNamespaceDir() {
+  const dir = getNamespaceDir();
+  await mkdir(dir, { recursive: true });
+  return dir;
+}
+
+async function readMetadata() {
+  const path = getMetadataPath();
+  try {
+    await access(path);
+    const content = await readFile(path, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+async function writeMetadata(data) {
+  await ensureNamespaceDir();
+  const path = getMetadataPath();
+  await writeFile(path, JSON.stringify(data, null, 2), "utf8");
+}
+
+async function namespaceExists() {
+  try {
+    await access(getNamespaceDir());
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  getNamespaceDir,
+  getMetadataPath,
+  getRcPath,
+  ensureNamespaceDir,
+  readMetadata,
+  writeMetadata,
+  namespaceExists,
+};

package/src/registry.js

@@ -0,0 +1,47 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = fileURLToPath(new URL("..", import.meta.url));
+const TEMPLATE_DIR = join(ROOT, "templates");
+
+function readJson(name) {
+  try {
+    const raw = readFileSync(join(TEMPLATE_DIR, name), "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Failed to load template ${name}: ${error.message}`);
+  }
+}
+
+export function loadMappings() {
+  const aliases = readJson("aliases.json");
+  const normalizedAliases = {};
+  for (const [key, value] of Object.entries(aliases)) {
+    normalizedAliases[normalizeIntentKey(key)] = value;
+  }
+
+  return {
+    mappings: {
+      ...readJson("lsp-mappings.json"),
+      ...readJson("git-mappings.json"),
+      ...readJson("navigation-mappings.json"),
+      ...readJson("editing-mappings.json"),
+    },
+    aliases: normalizedAliases,
+  };
+}
+
+export function lookupIntent(intent, editor, registry = loadMappings()) {
+  const key = normalizeIntentKey(intent);
+  const normalized = registry.aliases[key] ?? key;
+  return registry.mappings[normalized]?.[editor] ?? null;
+}
+
+function normalizeIntentKey(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+
+  return value.trim().toLowerCase().replace(/\s+/g, " ");
+}