mcp-config-migrator 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Industrial Curiosity
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+# mcp-config-migrator
+
+Interactively migrate and merge MCP (Model Context Protocol) server configurations between VS Code, Cursor, and Claude Code.
+
+If you configure MCP servers in one editor and want the same servers available in another — or want to keep two editors' configs in sync — this CLI walks you through picking a source and target, shows you what would change, lets you resolve any conflicts, and writes the result back in the target's native format.
+
+## Usage
+
+```sh
+npx mcp-config-migrator
+```
+
+You'll be asked to:
+
+1. Pick a **source** IDE and config scope/path (a sensible default is suggested and pre-filled, but always editable).
+2. Pick a **target** IDE and config scope/path the same way.
+3. Review any entries that exist in both configs with different definitions, and choose for each one: accept the source's version, accept the target's version, or merge — which opens an editor with both versions combined and conflicting fields marked git-style (`<<<<<<<`/`=======`/`>>>>>>>`) so you can resolve them by hand.
+4. Confirm a summary (added / unchanged / conflicts resolved) before anything is written.
+5. After writing, optionally remove any server entries from the target as a cleanup step.
+
+Nothing is written to disk until you explicitly confirm. Right before the write, you'll be asked whether to back up the target's *current* MCP server entries (not the rest of the file) to a version history — answer "Yes, always" or "No, never" to stop being asked and remember that choice for future runs, or "Yes"/"No" to decide just this once. Answering "Yes" (either form) also asks where to store the backup, pre-filled with the current default and editable; once a backup is written — including silently, when the preference is "always back up" — its storage location is always displayed. You can cancel at any prompt (Ctrl+C) with no changes made and no backup recorded.
+
+If you migrate into a Claude Code project-scope config (`.mcp.json`), Claude Code will ask you to re-approve the affected servers next time you open that project — the CLI tells you which servers and reminds you of `claude mcp reset-project-choices` if you'd rather not be prompted again.
+
+## Supported IDEs and config scopes
+
+| IDE | Scope | Config key | Default path |
+|---|---|---|---|
+| VS Code | Workspace | `servers` | `<project>/.vscode/mcp.json` |
+| VS Code | User | `servers` | macOS: `~/Library/Application Support/Code/User/mcp.json`; Linux: `$XDG_CONFIG_HOME/Code/User/mcp.json` (falls back to `~/.config/...`); Windows: `%APPDATA%\Code\User\mcp.json` |
+| Cursor | Global | `mcpServers` | `~/.cursor/mcp.json` (Windows: `%USERPROFILE%\.cursor\mcp.json`) |
+| Cursor | Project | `mcpServers` | `<project>/.cursor/mcp.json` |
+| Claude Code | User | `mcpServers` (inside `~/.claude.json`) | `$CLAUDE_CONFIG_DIR/.claude.json` if set, else `~/.claude.json` |
+| Claude Code | Project | `mcpServers` (inside `.mcp.json`) | `<project>/.mcp.json` |
+
+Every suggested path is shown as editable text — auto-detection is a convenience, not a requirement.
+
+VS Code requires a `type` (`stdio`/`http`/`sse`) on every entry; Cursor and Claude Code make `type` optional for `stdio` entries. Fields specific to one IDE (e.g. VS Code's `sandbox` options) are preserved when round-tripping through that same IDE, but dropped — with a warning — when migrating to a different IDE, since there's no equivalent field to write them into.
+
+Writes to `~/.claude.json` only touch the `mcpServers` key; OAuth session data, trust state, and any other content in that file is left untouched.
+
+## Backup and restore
+
+Backups (if you opt in) are appended to a single version history file, by default `~/mcp-config-migrator.versions.json`, holding every backed-up version across every target you've ever migrated to — nothing is ever removed or overwritten by normal use.
+
+```sh
+npx mcp-config-migrator restore                  # prompts for the version history file, defaulting to the canonical one
+npx mcp-config-migrator restore --file <path>    # or -f <path>
+npx mcp-config-migrator config backup            # view or change the backup preference and storage location
+npx mcp-config-migrator --help                   # or -h, /?
+```
+
+`restore` lists every saved version newest-first, lets you preview a version's server entries before committing, and on confirmation writes that version directly back to its original IDE/scope/path — restoring an older version doesn't remove any other version, so you can always restore forward again later.
+
+## Example run
+
+```
+┌  mcp-config-migrator
+◆  Migrate MCP servers FROM which IDE?
+│  ● Cursor
+◆  Which Cursor config scope?
+│  ● Global
+◆  Confirm the Cursor config path (Global):
+│  ~/.cursor/mcp.json
+◆  Migrate MCP servers TO which IDE?
+│  ● Claude Code
+◆  Which Claude Code config scope?
+│  ● Project (.mcp.json)
+◆  Confirm the Claude Code config path (Project (.mcp.json)):
+│  ./.mcp.json
+◆  Migration summary
+│  Added (2): fetch, github
+│  Unchanged (1): filesystem
+│  Conflicts resolved (0):
+│    accept target (0)
+│    accept source (0)
+│    merged (0)
+◆  Write merged config to ./.mcp.json?
+│  Yes
+◆  Back up the current MCP servers in ./.mcp.json before writing?
+│  ● Yes, always
+◆  Backup storage location:
+│  ~/mcp-config-migrator.versions.json
+✔  Backed up current MCP servers for ./.mcp.json to ~/mcp-config-migrator.versions.json
+✔  Wrote merged config to ./.mcp.json
+◆  Remove any MCP servers from the target before finishing? (none required)
+│  (none selected)
+└  Done.
+```
+
+## Development
+
+```sh
+npm install
+npm run build      # compile to dist/
+npm run test       # run the test suite
+npm run lint         # lint
+npm run typecheck   # type-check without emitting
+```

package/dist/chunk-E2A5N2LX.js

@@ -0,0 +1,467 @@
+// src/model/equality.ts
+function arraysEqual(a, b) {
+  if (a === void 0 || b === void 0) return a === b;
+  if (a.length !== b.length) return false;
+  return a.every((value, index) => value === b[index]);
+}
+function recordsEqual(a, b) {
+  if (a === void 0 || b === void 0) return a === b;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every((key) => a[key] === b[key]);
+}
+function areServersEqual(a, b) {
+  return a.name === b.name && a.transport === b.transport && a.command === b.command && a.cwd === b.cwd && a.url === b.url && arraysEqual(a.args, b.args) && recordsEqual(a.env, b.env) && recordsEqual(a.headers, b.headers);
+}
+
+// src/model/versionsStore.ts
+import { readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+function defaultSettingsPath() {
+  return join(homedir(), "mcp-config-migrator.versions.json");
+}
+async function readJsonFile(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+async function writeJsonFile(path, data) {
+  await writeFile(path, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+}
+async function readVersionsStore(settingsPath) {
+  const settings = await readJsonFile(settingsPath);
+  const configured = settings.configured ?? "alwaysAsk";
+  const backupLocation = settings.backupLocation;
+  const versionsPath = backupLocation ?? settingsPath;
+  const versions = backupLocation ? (await readJsonFile(versionsPath)).versions ?? [] : settings.versions ?? [];
+  return { settingsPath, configured, backupLocation, versionsPath, versions };
+}
+async function setPreference(settingsPath, configured) {
+  const settings = await readJsonFile(settingsPath);
+  await writeJsonFile(settingsPath, { ...settings, configured });
+}
+async function setBackupLocation(settingsPath, backupLocation) {
+  const settings = await readJsonFile(settingsPath);
+  const next = { ...settings };
+  if (backupLocation) {
+    next.backupLocation = backupLocation;
+  } else {
+    delete next.backupLocation;
+  }
+  await writeJsonFile(settingsPath, next);
+}
+async function appendVersion(settingsPath, entry) {
+  const store = await readVersionsStore(settingsPath);
+  const versions = [...store.versions, entry];
+  if (store.backupLocation) {
+    await writeJsonFile(store.versionsPath, { versions });
+  } else {
+    const settings = await readJsonFile(settingsPath);
+    await writeJsonFile(settingsPath, { ...settings, versions });
+  }
+}
+
+// src/adapters/vscode.ts
+import { parse as parseJsonc, modify, applyEdits } from "jsonc-parser";
+
+// src/adapters/fileIO.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir } from "fs/promises";
+import { dirname } from "path";
+async function readTextFile(path) {
+  try {
+    return await readFile2(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return "";
+    throw err;
+  }
+}
+async function writeTextFile(path, content) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile2(path, content, "utf8");
+}
+function parseJsonObject(text) {
+  if (text.trim() === "") return {};
+  const parsed = JSON.parse(text);
+  return typeof parsed === "object" && parsed !== null ? parsed : {};
+}
+
+// src/adapters/entryFields.ts
+var STDIO_FIELDS = ["type", "command", "args", "cwd", "env"];
+var REMOTE_FIELDS = ["type", "url", "headers"];
+function entryToNormalized(name, raw, ideId, defaultTransport = "stdio") {
+  const transport = raw.type ?? defaultTransport;
+  const knownKeys = transport === "stdio" ? STDIO_FIELDS : REMOTE_FIELDS;
+  const extraFields = {};
+  for (const key of Object.keys(raw)) {
+    if (!knownKeys.includes(key)) extraFields[key] = raw[key];
+  }
+  const server = { name, transport };
+  if (transport === "stdio") {
+    if (typeof raw.command === "string") server.command = raw.command;
+    if (Array.isArray(raw.args)) server.args = raw.args;
+    if (typeof raw.cwd === "string") server.cwd = raw.cwd;
+    if (raw.env && typeof raw.env === "object") server.env = raw.env;
+  } else {
+    if (typeof raw.url === "string") server.url = raw.url;
+    if (raw.headers && typeof raw.headers === "object") {
+      server.headers = raw.headers;
+    }
+  }
+  if (Object.keys(extraFields).length > 0) {
+    server.extra = { sourceIdeId: ideId, fields: extraFields };
+  }
+  return server;
+}
+function normalizedToEntry(server, ideId, includeType) {
+  const entry = {};
+  if (includeType || server.transport !== "stdio") {
+    entry.type = server.transport;
+  }
+  if (server.transport === "stdio") {
+    if (server.command !== void 0) entry.command = server.command;
+    if (server.args !== void 0) entry.args = server.args;
+    if (server.cwd !== void 0) entry.cwd = server.cwd;
+    if (server.env !== void 0) entry.env = server.env;
+  } else {
+    if (server.url !== void 0) entry.url = server.url;
+    if (server.headers !== void 0) entry.headers = server.headers;
+  }
+  let droppedFields = [];
+  if (server.extra) {
+    if (server.extra.sourceIdeId === ideId) {
+      Object.assign(entry, server.extra.fields);
+    } else {
+      droppedFields = Object.keys(server.extra.fields);
+    }
+  }
+  return { entry, droppedFields };
+}
+
+// src/adapters/paths.ts
+import { posix, win32 } from "path";
+function homeDir(env, platform) {
+  if (platform === "win32") return env.USERPROFILE ?? env.HOME ?? "";
+  return env.HOME ?? "";
+}
+function joinForPlatform(platform, ...segments) {
+  return (platform === "win32" ? win32 : posix).join(...segments);
+}
+
+// src/adapters/vscode.ts
+var IDE_ID = "vscode";
+var SERVERS_KEY = "servers";
+function userConfigDir(env, platform) {
+  const home = homeDir(env, platform);
+  if (platform === "darwin") {
+    return joinForPlatform(platform, home, "Library", "Application Support", "Code", "User");
+  }
+  if (platform === "win32") {
+    return joinForPlatform(
+      platform,
+      env.APPDATA ?? joinForPlatform(platform, home, "AppData", "Roaming"),
+      "Code",
+      "User"
+    );
+  }
+  return joinForPlatform(platform, env.XDG_CONFIG_HOME ?? joinForPlatform(platform, home, ".config"), "Code", "User");
+}
+var vscodeAdapter = {
+  id: IDE_ID,
+  label: "VS Code",
+  resolveDefaultPaths(env, platform, cwd) {
+    return [
+      {
+        scopeId: "workspace",
+        label: "Workspace (.vscode/mcp.json)",
+        path: joinForPlatform(platform, cwd, ".vscode", "mcp.json")
+      },
+      {
+        scopeId: "user",
+        label: "User",
+        path: joinForPlatform(platform, userConfigDir(env, platform), "mcp.json")
+      }
+    ];
+  },
+  async load(path) {
+    const text = await readTextFile(path);
+    const doc = text.trim() === "" ? {} : parseJsonc(text);
+    const serversRaw = doc[SERVERS_KEY] ?? {};
+    const servers = Object.entries(serversRaw).map(
+      ([name, raw]) => entryToNormalized(name, raw, IDE_ID, "stdio")
+    );
+    return { servers };
+  },
+  async save(path, normalized) {
+    const originalText = await readTextFile(path);
+    const serversValue = {};
+    const droppedFields = [];
+    for (const server of normalized.servers) {
+      const { entry, droppedFields: dropped } = normalizedToEntry(server, IDE_ID, true);
+      serversValue[server.name] = entry;
+      if (dropped.length > 0) {
+        droppedFields.push({ serverName: server.name, fields: dropped });
+      }
+    }
+    const formattingOptions = { tabSize: 2, insertSpaces: true, eol: "\n" };
+    const edits = modify(originalText, [SERVERS_KEY], serversValue, { formattingOptions });
+    const newText = applyEdits(originalText, edits);
+    await writeTextFile(path, newText);
+    return { droppedFields };
+  }
+};
+
+// src/adapters/cursor.ts
+var IDE_ID2 = "cursor";
+var SERVERS_KEY2 = "mcpServers";
+var cursorAdapter = {
+  id: IDE_ID2,
+  label: "Cursor",
+  resolveDefaultPaths(env, platform, cwd) {
+    const home = homeDir(env, platform);
+    return [
+      {
+        scopeId: "global",
+        label: "Global",
+        path: joinForPlatform(platform, home, ".cursor", "mcp.json")
+      },
+      {
+        scopeId: "project",
+        label: "Project (.cursor/mcp.json)",
+        path: joinForPlatform(platform, cwd, ".cursor", "mcp.json")
+      }
+    ];
+  },
+  async load(path) {
+    const text = await readTextFile(path);
+    const doc = parseJsonObject(text);
+    const serversRaw = doc[SERVERS_KEY2] ?? {};
+    const servers = Object.entries(serversRaw).map(
+      ([name, raw]) => entryToNormalized(name, raw, IDE_ID2, "stdio")
+    );
+    return { servers };
+  },
+  async save(path, normalized) {
+    const text = await readTextFile(path);
+    const doc = parseJsonObject(text);
+    const serversValue = {};
+    const droppedFields = [];
+    for (const server of normalized.servers) {
+      const { entry, droppedFields: dropped } = normalizedToEntry(server, IDE_ID2, false);
+      serversValue[server.name] = entry;
+      if (dropped.length > 0) {
+        droppedFields.push({ serverName: server.name, fields: dropped });
+      }
+    }
+    doc[SERVERS_KEY2] = serversValue;
+    await writeTextFile(path, `${JSON.stringify(doc, null, 2)}
+`);
+    return { droppedFields };
+  }
+};
+
+// src/adapters/claudeCode.ts
+var IDE_ID3 = "claude-code";
+var SERVERS_KEY3 = "mcpServers";
+var claudeCodeAdapter = {
+  id: IDE_ID3,
+  label: "Claude Code",
+  resolveDefaultPaths(env, platform, cwd) {
+    const userConfigDir2 = env.CLAUDE_CONFIG_DIR ?? homeDir(env, platform);
+    return [
+      {
+        scopeId: "user",
+        label: "User (~/.claude.json)",
+        path: joinForPlatform(platform, userConfigDir2, ".claude.json")
+      },
+      {
+        scopeId: "project",
+        label: "Project (.mcp.json)",
+        path: joinForPlatform(platform, cwd, ".mcp.json")
+      }
+    ];
+  },
+  async load(path) {
+    const text = await readTextFile(path);
+    const doc = parseJsonObject(text);
+    const serversRaw = doc[SERVERS_KEY3] ?? {};
+    const servers = Object.entries(serversRaw).map(
+      ([name, raw]) => entryToNormalized(name, raw, IDE_ID3, "stdio")
+    );
+    return { servers };
+  },
+  async save(path, normalized) {
+    const text = await readTextFile(path);
+    const doc = parseJsonObject(text);
+    const serversValue = {};
+    const droppedFields = [];
+    for (const server of normalized.servers) {
+      const { entry, droppedFields: dropped } = normalizedToEntry(server, IDE_ID3, false);
+      serversValue[server.name] = entry;
+      if (dropped.length > 0) {
+        droppedFields.push({ serverName: server.name, fields: dropped });
+      }
+    }
+    doc[SERVERS_KEY3] = serversValue;
+    await writeTextFile(path, `${JSON.stringify(doc, null, 2)}
+`);
+    return { droppedFields };
+  }
+};
+
+// src/adapters/registry.ts
+var adapters = [vscodeAdapter, cursorAdapter, claudeCodeAdapter];
+var adapterById = new Map(adapters.map((adapter) => [adapter.id, adapter]));
+function getAdapter(id) {
+  const adapter = adapterById.get(id);
+  if (!adapter) {
+    throw new Error(`Unknown IDE adapter: ${id}`);
+  }
+  return adapter;
+}
+
+// src/engine/classify.ts
+function classify(source, target) {
+  const targetByName = new Map(target.servers.map((server) => [server.name, server]));
+  return source.servers.map((sourceServer) => {
+    const targetServer = targetByName.get(sourceServer.name);
+    if (!targetServer) {
+      return { name: sourceServer.name, kind: "add", source: sourceServer };
+    }
+    const kind = areServersEqual(sourceServer, targetServer) ? "unchanged" : "conflict";
+    return { name: sourceServer.name, kind, source: sourceServer, target: targetServer };
+  });
+}
+
+// src/engine/diff.ts
+import { diffLines } from "diff";
+function forDisplay(server) {
+  const { name: _name, extra, ...rest } = server;
+  const display = { ...rest };
+  if (extra) display.extra = extra.fields;
+  return display;
+}
+function renderConflictDiff(entry) {
+  if (entry.kind !== "conflict" || !entry.target) {
+    throw new Error(`renderConflictDiff requires a conflict entry: ${entry.name}`);
+  }
+  const targetJson = `${JSON.stringify(forDisplay(entry.target), null, 2)}
+`;
+  const sourceJson = `${JSON.stringify(forDisplay(entry.source), null, 2)}
+`;
+  const changes = diffLines(targetJson, sourceJson);
+  return changes.map((change) => {
+    const prefix = change.added ? "+" : change.removed ? "-" : " ";
+    return change.value.split("\n").filter((line, index, lines) => !(index === lines.length - 1 && line === "")).map((line) => `${prefix} ${line}`).join("\n");
+  }).join("\n");
+}
+function renderMergeScaffold(entry) {
+  if (entry.kind !== "conflict" || !entry.target) {
+    throw new Error(`renderMergeScaffold requires a conflict entry: ${entry.name}`);
+  }
+  const targetJson = `${JSON.stringify(forDisplay(entry.target), null, 2)}
+`;
+  const sourceJson = `${JSON.stringify(forDisplay(entry.source), null, 2)}
+`;
+  const changes = diffLines(targetJson, sourceJson);
+  const out = [];
+  for (let i = 0; i < changes.length; i++) {
+    const change = changes[i];
+    if (!change.added && !change.removed) {
+      out.push(change.value);
+      continue;
+    }
+    if (change.removed) {
+      const next = changes[i + 1];
+      const sourceValue = next?.added ? next.value : "";
+      if (next?.added) i++;
+      out.push(conflictBlock(change.value, sourceValue));
+      continue;
+    }
+    out.push(conflictBlock("", change.value));
+  }
+  return out.join("");
+}
+function conflictBlock(targetLines, sourceLines) {
+  return `<<<<<<< target
+${targetLines}=======
+${sourceLines}>>>>>>> source
+`;
+}
+
+// src/engine/merge.ts
+function applyMerge(target, classifications, resolutions) {
+  const resultByName = new Map(target.servers.map((server) => [server.name, server]));
+  for (const entry of classifications) {
+    if (entry.kind === "add") {
+      resultByName.set(entry.name, entry.source);
+    } else if (entry.kind === "conflict") {
+      const resolution = resolutions[entry.name] ?? { kind: "accept-target" };
+      if (resolution.kind === "accept-source") {
+        resultByName.set(entry.name, entry.source);
+      } else if (resolution.kind === "merge") {
+        resultByName.set(entry.name, resolution.merged);
+      }
+    }
+  }
+  return { servers: Array.from(resultByName.values()) };
+}
+
+// src/engine/summary.ts
+function toCategory(names) {
+  return { count: names.length, names };
+}
+function summarize(classifications, resolutions) {
+  const added = [];
+  const unchanged = [];
+  const acceptTarget = [];
+  const acceptSource = [];
+  const merged = [];
+  for (const entry of classifications) {
+    if (entry.kind === "add") {
+      added.push(entry.name);
+    } else if (entry.kind === "unchanged") {
+      unchanged.push(entry.name);
+    } else {
+      const resolution = resolutions[entry.name] ?? { kind: "accept-target" };
+      if (resolution.kind === "accept-target") acceptTarget.push(entry.name);
+      else if (resolution.kind === "accept-source") acceptSource.push(entry.name);
+      else merged.push(entry.name);
+    }
+  }
+  return {
+    added: toCategory(added),
+    unchanged: toCategory(unchanged),
+    conflicts: {
+      total: acceptTarget.length + acceptSource.length + merged.length,
+      acceptTarget: toCategory(acceptTarget),
+      acceptSource: toCategory(acceptSource),
+      merged: toCategory(merged)
+    }
+  };
+}
+function isNoOp(classifications) {
+  return classifications.every((entry) => entry.kind === "unchanged");
+}
+
+export {
+  areServersEqual,
+  defaultSettingsPath,
+  readVersionsStore,
+  setPreference,
+  setBackupLocation,
+  appendVersion,
+  adapters,
+  getAdapter,
+  classify,
+  renderConflictDiff,
+  renderMergeScaffold,
+  applyMerge,
+  summarize,
+  isNoOp
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,508 @@
+#!/usr/bin/env node
+import {
+  adapters,
+  appendVersion,
+  applyMerge,
+  classify,
+  defaultSettingsPath,
+  getAdapter,
+  isNoOp,
+  readVersionsStore,
+  renderConflictDiff,
+  renderMergeScaffold,
+  setBackupLocation,
+  setPreference,
+  summarize
+} from "./chunk-E2A5N2LX.js";
+
+// src/cli/args.ts
+function parseArgs(argv) {
+  const [first, ...rest] = argv;
+  if (first === void 0) return { kind: "migrate" };
+  if (first === "--help" || first === "-h" || first === "/?") return { kind: "help" };
+  if (first === "restore") {
+    const flagIndex = rest.findIndex((arg) => arg === "--file" || arg === "-f");
+    const filePath = flagIndex >= 0 ? rest[flagIndex + 1] : void 0;
+    return { kind: "restore", filePath };
+  }
+  if (first === "config" && rest[0] === "backup") return { kind: "config-backup" };
+  return { kind: "help" };
+}
+
+// src/cli/configBackupFlow.ts
+import * as p2 from "@clack/prompts";
+
+// src/cli/cancel.ts
+import * as p from "@clack/prompts";
+var CliCancelled = class extends Error {
+};
+function unwrap(value) {
+  if (p.isCancel(value)) {
+    throw new CliCancelled();
+  }
+  return value;
+}
+async function withCancelHandling(fn) {
+  try {
+    await fn();
+  } catch (err) {
+    if (err instanceof CliCancelled) {
+      p.cancel("Cancelled.");
+      return;
+    }
+    throw err;
+  }
+}
+
+// src/cli/configBackupFlow.ts
+var PREFERENCE_LABELS = {
+  alwaysAsk: "Always ask",
+  alwaysOn: "Always back up",
+  alwaysOff: "Never back up"
+};
+async function configBackupFlow(options) {
+  const settingsPath = options.settingsPath ?? defaultSettingsPath();
+  p2.intro("mcp-config-migrator config backup");
+  const store = await readVersionsStore(settingsPath);
+  p2.note(
+    [`Backup preference: ${PREFERENCE_LABELS[store.configured]}`, `Storage location: ${store.versionsPath}`].join("\n"),
+    "Current settings"
+  );
+  const preference = unwrap(
+    await p2.select({
+      message: "Backup preference:",
+      options: Object.keys(PREFERENCE_LABELS).map((value) => ({
+        value,
+        label: PREFERENCE_LABELS[value]
+      })),
+      initialValue: store.configured
+    })
+  );
+  if (preference !== store.configured) {
+    await setPreference(settingsPath, preference);
+  }
+  const location = unwrap(
+    await p2.text({
+      message: "Storage location for the version history:",
+      initialValue: store.versionsPath
+    })
+  );
+  const nextLocation = location === settingsPath ? void 0 : location;
+  if (nextLocation !== store.backupLocation) {
+    await setBackupLocation(settingsPath, nextLocation);
+  }
+  p2.outro("Backup settings updated.");
+}
+async function runConfigBackup(options = {}) {
+  await withCancelHandling(() => configBackupFlow(options));
+}
+
+// src/cli/flow.ts
+import * as p5 from "@clack/prompts";
+
+// src/cli/backupFlow.ts
+import * as p3 from "@clack/prompts";
+async function maybeBackup(settingsPath, target) {
+  const store = await readVersionsStore(settingsPath);
+  if (store.configured === "alwaysOff") return;
+  if (store.configured === "alwaysOn") {
+    await backupNow(settingsPath, store.versionsPath, target);
+    return;
+  }
+  const choice = unwrap(
+    await p3.select({
+      message: `Back up the current MCP servers in ${target.path} before writing?`,
+      options: [
+        { value: "yes", label: "Yes" },
+        { value: "yes-always", label: "Yes, always" },
+        { value: "no", label: "No" },
+        { value: "no-never", label: "No, never" }
+      ],
+      initialValue: "yes-always"
+    })
+  );
+  if (choice === "yes" || choice === "yes-always") {
+    const location = unwrap(
+      await p3.text({
+        message: "Backup storage location:",
+        initialValue: store.versionsPath
+      })
+    );
+    if (location !== store.versionsPath) {
+      await setBackupLocation(settingsPath, location === settingsPath ? void 0 : location);
+    }
+    await backupNow(settingsPath, location, target);
+  }
+  if (choice === "yes-always") {
+    await setPreference(settingsPath, "alwaysOn");
+  } else if (choice === "no-never") {
+    await setPreference(settingsPath, "alwaysOff");
+  }
+}
+async function backupNow(settingsPath, versionsPath, target) {
+  await appendVersion(settingsPath, {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ideId: target.ideId,
+    scopeId: target.scopeId,
+    path: target.path,
+    servers: target.config.servers
+  });
+  p3.log.success(`Backed up current MCP servers for ${target.path} to ${versionsPath}`);
+}
+
+// src/cli/mergeFlow.ts
+import * as p4 from "@clack/prompts";
+
+// src/cli/editor.ts
+import { spawnSync } from "child_process";
+import { mkdtemp, readFile, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+function resolveEditorCommand(env, platform) {
+  return env.VISUAL || env.EDITOR || (platform === "win32" ? "notepad" : "vi");
+}
+async function editText(text5, env, platform) {
+  const dir = await mkdtemp(join(tmpdir(), "mcp-config-migrator-merge-"));
+  const filePath = join(dir, "entry.json");
+  try {
+    await writeFile(filePath, text5, "utf8");
+    const command = resolveEditorCommand(env, platform);
+    const result = spawnSync(`${command} "${filePath}"`, { shell: true, stdio: "inherit" });
+    if (result.error) {
+      throw new Error(`Failed to launch editor "${command}": ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+      throw new Error(`Editor "${command}" exited with status ${result.status}`);
+    }
+    return await readFile(filePath, "utf8");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+// src/engine/mergeParse.ts
+var TRANSPORTS = ["stdio", "http", "sse"];
+var STDIO_KEYS = ["transport", "command", "args", "cwd", "env"];
+var REMOTE_KEYS = ["transport", "url", "headers"];
+var MARKER_PATTERN = /^(<{7}|={7}|>{7})/m;
+var MergeValidationError = class extends Error {
+};
+function hasUnresolvedMarkers(text5) {
+  return MARKER_PATTERN.test(text5);
+}
+function isStringRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((v) => typeof v === "string");
+}
+function parseMergedServer(name, text5) {
+  if (hasUnresolvedMarkers(text5)) {
+    throw new MergeValidationError(
+      "Unresolved conflict markers remain. Remove every <<<<<<<, =======, and >>>>>>> line before saving."
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text5);
+  } catch (err) {
+    throw new MergeValidationError(`Invalid JSON: ${err.message}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new MergeValidationError("The merged entry must be a JSON object.");
+  }
+  const raw = parsed;
+  if (!TRANSPORTS.includes(raw.transport)) {
+    throw new MergeValidationError(`"transport" must be one of: ${TRANSPORTS.join(", ")}`);
+  }
+  const transport = raw.transport;
+  const allowedKeys = transport === "stdio" ? STDIO_KEYS : REMOTE_KEYS;
+  const unknownKeys = Object.keys(raw).filter((key) => !allowedKeys.includes(key));
+  if (unknownKeys.length > 0) {
+    throw new MergeValidationError(`Unrecognized field(s): ${unknownKeys.join(", ")}`);
+  }
+  const server = { name, transport };
+  if (transport === "stdio") {
+    if (raw.command !== void 0) {
+      if (typeof raw.command !== "string") throw new MergeValidationError(`"command" must be a string`);
+      server.command = raw.command;
+    }
+    if (raw.args !== void 0) {
+      if (!Array.isArray(raw.args) || !raw.args.every((a) => typeof a === "string")) {
+        throw new MergeValidationError(`"args" must be an array of strings`);
+      }
+      server.args = raw.args;
+    }
+    if (raw.cwd !== void 0) {
+      if (typeof raw.cwd !== "string") throw new MergeValidationError(`"cwd" must be a string`);
+      server.cwd = raw.cwd;
+    }
+    if (raw.env !== void 0) {
+      if (!isStringRecord(raw.env)) throw new MergeValidationError(`"env" must be an object of string values`);
+      server.env = raw.env;
+    }
+  } else {
+    if (raw.url !== void 0) {
+      if (typeof raw.url !== "string") throw new MergeValidationError(`"url" must be a string`);
+      server.url = raw.url;
+    }
+    if (raw.headers !== void 0) {
+      if (!isStringRecord(raw.headers)) {
+        throw new MergeValidationError(`"headers" must be an object of string values`);
+      }
+      server.headers = raw.headers;
+    }
+  }
+  return server;
+}
+
+// src/cli/mergeFlow.ts
+async function resolveMergeConflict(entry, env, platform) {
+  const original = renderMergeScaffold(entry);
+  let current = original;
+  for (; ; ) {
+    const edited = await editText(current, env, platform);
+    try {
+      return parseMergedServer(entry.name, edited);
+    } catch (err) {
+      if (!(err instanceof MergeValidationError)) throw err;
+      current = edited;
+      p4.log.error(err.message);
+      const choice = await p4.select({
+        message: "Resolve the error:",
+        options: [
+          { value: "fix", label: "Fix \u2014 reopen the editor with your edits kept" },
+          { value: "redo", label: "Redo \u2014 reopen the editor reset to the original conflict markers" }
+        ]
+      });
+      if (unwrap(choice) === "redo") {
+        current = original;
+      }
+    }
+  }
+}
+
+// src/cli/flow.ts
+async function selectIde(message) {
+  const choice = await p5.select({
+    message,
+    options: adapters.map((adapter) => ({ value: adapter.id, label: adapter.label }))
+  });
+  return unwrap(choice);
+}
+async function selectScopeAndPath(ideLabel, candidates) {
+  let candidate = candidates[0];
+  if (candidates.length > 1) {
+    const scopeId = await p5.select({
+      message: `Which ${ideLabel} config scope?`,
+      options: candidates.map((c) => ({ value: c.scopeId, label: c.label, hint: c.path }))
+    });
+    candidate = candidates.find((c) => c.scopeId === unwrap(scopeId));
+  }
+  const path = await p5.text({
+    message: `Confirm the ${ideLabel} config path (${candidate.label}):`,
+    initialValue: candidate.path,
+    validate: (value) => !value || value.trim() === "" ? "A path is required" : void 0
+  });
+  return { scopeId: candidate.scopeId, path: unwrap(path) };
+}
+async function resolveConflicts(conflicts, env, platform) {
+  const resolutions = {};
+  for (const entry of conflicts) {
+    p5.note(renderConflictDiff(entry), `Conflict: ${entry.name}`);
+    const choice = await p5.select({
+      message: `Resolve "${entry.name}":`,
+      options: [
+        { value: "accept-target", label: "Accept target's definition" },
+        { value: "accept-source", label: "Accept source's definition" },
+        { value: "merge", label: "Merge\u2026" }
+      ]
+    });
+    const resolved = unwrap(choice);
+    if (resolved === "merge") {
+      const merged = await resolveMergeConflict(entry, env, platform);
+      resolutions[entry.name] = { kind: "merge", merged };
+    } else {
+      resolutions[entry.name] = { kind: resolved };
+    }
+  }
+  return resolutions;
+}
+function changedServerNames(classifications, resolutions) {
+  return classifications.filter(
+    (entry) => entry.kind === "add" || entry.kind === "conflict" && (resolutions[entry.name]?.kind === "accept-source" || resolutions[entry.name]?.kind === "merge")
+  ).map((entry) => entry.name);
+}
+async function runFlow(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const settingsPath = options.settingsPath ?? defaultSettingsPath();
+  p5.intro("mcp-config-migrator");
+  const sourceIdeId = await selectIde("Migrate MCP servers FROM which IDE?");
+  const sourceAdapter = getAdapter(sourceIdeId);
+  const source = await selectScopeAndPath(
+    sourceAdapter.label,
+    sourceAdapter.resolveDefaultPaths(env, platform, cwd)
+  );
+  const targetIdeId = await selectIde("Migrate MCP servers TO which IDE?");
+  const targetAdapter = getAdapter(targetIdeId);
+  const target = await selectScopeAndPath(
+    targetAdapter.label,
+    targetAdapter.resolveDefaultPaths(env, platform, cwd)
+  );
+  const sourceConfig = await sourceAdapter.load(source.path);
+  const targetConfig = await targetAdapter.load(target.path);
+  const classifications = classify(sourceConfig, targetConfig);
+  if (isNoOp(classifications)) {
+    p5.outro("Nothing to migrate \u2014 target already has every source entry.");
+    return;
+  }
+  const conflicts = classifications.filter((entry) => entry.kind === "conflict");
+  const resolutions = await resolveConflicts(conflicts, env, platform);
+  const summary = summarize(classifications, resolutions);
+  const formatCategory = (label, category) => category.count === 0 ? `${label} (0)` : `${label} (${category.count}): ${category.names.join(", ")}`;
+  p5.note(
+    [
+      formatCategory("Added", summary.added),
+      formatCategory("Unchanged", summary.unchanged),
+      `Conflicts resolved (${summary.conflicts.total}):`,
+      `  ${formatCategory("accept target", summary.conflicts.acceptTarget)}`,
+      `  ${formatCategory("accept source", summary.conflicts.acceptSource)}`,
+      `  ${formatCategory("merged", summary.conflicts.merged)}`
+    ].join("\n"),
+    "Migration summary"
+  );
+  const confirmed = unwrap(await p5.confirm({ message: `Write merged config to ${target.path}?` }));
+  if (!confirmed) {
+    p5.outro("No changes were made.");
+    return;
+  }
+  const merged = applyMerge(targetConfig, classifications, resolutions);
+  if (targetAdapter.id === "claude-code" && target.scopeId === "project") {
+    const names = changedServerNames(classifications, resolutions);
+    if (names.length > 0) {
+      p5.note(
+        [
+          `Claude Code will ask you to re-approve: ${names.join(", ")}`,
+          "If you'd rather not be prompted again, run:",
+          "  claude mcp reset-project-choices"
+        ].join("\n"),
+        "Heads up"
+      );
+    }
+  }
+  await maybeBackup(settingsPath, {
+    ideId: targetAdapter.id,
+    scopeId: target.scopeId,
+    path: target.path,
+    config: targetConfig
+  });
+  const saveResult = await targetAdapter.save(target.path, merged);
+  for (const dropped of saveResult.droppedFields) {
+    p5.log.warn(`Dropped fields for "${dropped.serverName}" not supported by ${targetAdapter.label}: ${dropped.fields.join(", ")}`);
+  }
+  p5.log.success(`Wrote merged config to ${target.path}`);
+  await runCleanup(targetAdapter, target.path, merged);
+  p5.outro("Done.");
+}
+async function runCleanup(targetAdapter, targetPath, merged) {
+  if (merged.servers.length === 0) return;
+  const result = await p5.multiselect({
+    message: "Remove any MCP servers from the target before finishing? (none required)",
+    options: merged.servers.map((server) => ({ value: server.name, label: server.name })),
+    required: false
+  });
+  if (p5.isCancel(result)) {
+    p5.log.info("Skipped cleanup.");
+    return;
+  }
+  const toRemove = result;
+  if (toRemove.length === 0) return;
+  const remaining = {
+    servers: merged.servers.filter((server) => !toRemove.includes(server.name))
+  };
+  await targetAdapter.save(targetPath, remaining);
+  p5.log.success(`Removed: ${toRemove.join(", ")}`);
+}
+async function runCli(options = {}) {
+  await withCancelHandling(() => runFlow(options));
+}
+
+// src/cli/restoreFlow.ts
+import * as p6 from "@clack/prompts";
+function formatVersionLabel(version) {
+  const adapter = getAdapter(version.ideId);
+  return `${version.timestamp} \u2014 ${adapter.label} (${version.scopeId}) \u2014 ${version.path}`;
+}
+async function restoreFlow(options) {
+  p6.intro("mcp-config-migrator restore");
+  let settingsPath = options.filePath;
+  if (!settingsPath) {
+    settingsPath = unwrap(
+      await p6.text({
+        message: "Path to the versions file to restore from:",
+        initialValue: defaultSettingsPath()
+      })
+    );
+  }
+  const store = await readVersionsStore(settingsPath);
+  if (store.versions.length === 0) {
+    p6.outro(`No backed-up versions found in ${store.versionsPath}.`);
+    return;
+  }
+  const sorted = [...store.versions].sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  const selectedIndex = unwrap(
+    await p6.select({
+      message: "Select a version to restore:",
+      options: sorted.map((version2, index) => ({ value: index, label: formatVersionLabel(version2) }))
+    })
+  );
+  const version = sorted[selectedIndex];
+  p6.note(JSON.stringify(version.servers, null, 2), `Preview: ${formatVersionLabel(version)}`);
+  const confirmed = unwrap(await p6.confirm({ message: `Overwrite ${version.path} with this version?` }));
+  if (!confirmed) {
+    p6.outro("Restore cancelled. No changes were made.");
+    return;
+  }
+  const adapter = getAdapter(version.ideId);
+  await adapter.save(version.path, { servers: version.servers });
+  p6.log.success(`Restored ${version.path} from ${version.timestamp}.`);
+  p6.outro("Done.");
+}
+async function runRestore(options = {}) {
+  await withCancelHandling(() => restoreFlow(options));
+}
+
+// src/cli/index.ts
+function printHelp() {
+  console.log(
+    [
+      "mcp-config-migrator",
+      "",
+      "Usage:",
+      "  mcp-config-migrator                       Interactively migrate MCP servers between IDEs",
+      "  mcp-config-migrator restore [--file|-f <path>]",
+      "                                             Restore a previously backed-up version",
+      "  mcp-config-migrator config backup          View or change the backup preference and storage location",
+      "  mcp-config-migrator --help, -h, /?         Show this help"
+    ].join("\n")
+  );
+}
+try {
+  const command = parseArgs(process.argv.slice(2));
+  switch (command.kind) {
+    case "migrate":
+      await runCli();
+      break;
+    case "restore":
+      await runRestore({ filePath: command.filePath });
+      break;
+    case "config-backup":
+      await runConfigBackup();
+      break;
+    case "help":
+      printHelp();
+      break;
+  }
+} catch (err) {
+  console.error(err instanceof Error ? err.message : err);
+  process.exitCode = 1;
+}

package/dist/index.d.ts

@@ -0,0 +1,136 @@
+type Transport = "stdio" | "http" | "sse";
+/**
+ * Fields outside the common shape, tagged with the IDE that produced them.
+ * Only re-emitted when serializing back through the same IDE's adapter;
+ * dropped (with a warning) when migrating cross-IDE.
+ */
+interface ExtraFields {
+    sourceIdeId: string;
+    fields: Record<string, unknown>;
+}
+interface NormalizedMcpServer {
+    name: string;
+    transport: Transport;
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+    extra?: ExtraFields;
+}
+interface NormalizedConfig {
+    servers: NormalizedMcpServer[];
+}
+
+/**
+ * Compares the common normalized shape only — the adapter-specific `extra`
+ * bag is excluded so cross-IDE entries that match on every shared field are
+ * still classified as Unchanged.
+ */
+declare function areServersEqual(a: NormalizedMcpServer, b: NormalizedMcpServer): boolean;
+
+type BackupPreference = "alwaysAsk" | "alwaysOn" | "alwaysOff";
+interface BackupVersion {
+    timestamp: string;
+    ideId: string;
+    scopeId: string;
+    path: string;
+    servers: NormalizedMcpServer[];
+}
+interface VersionsStore {
+    settingsPath: string;
+    configured: BackupPreference;
+    backupLocation?: string;
+    /** The file `versions` is actually read from/written to: `backupLocation` if set, otherwise `settingsPath`. */
+    versionsPath: string;
+    versions: BackupVersion[];
+}
+declare function defaultSettingsPath(): string;
+declare function readVersionsStore(settingsPath: string): Promise<VersionsStore>;
+declare function setPreference(settingsPath: string, configured: BackupPreference): Promise<void>;
+declare function setBackupLocation(settingsPath: string, backupLocation: string | undefined): Promise<void>;
+/** Appends `entry` to the resolved store's version history without altering or removing any existing entry. */
+declare function appendVersion(settingsPath: string, entry: BackupVersion): Promise<void>;
+
+interface DefaultPathCandidate {
+    /** Stable id for the scope this path belongs to, e.g. "user", "project". */
+    scopeId: string;
+    /** Human-readable label shown in CLI prompts, e.g. "User", "Project (.mcp.json)". */
+    label: string;
+    path: string;
+}
+interface DroppedExtraFields {
+    serverName: string;
+    fields: string[];
+}
+interface SaveResult {
+    /** Adapter-specific fields that couldn't be re-emitted because they came from a different IDE. */
+    droppedFields: DroppedExtraFields[];
+}
+interface IdeAdapter {
+    id: string;
+    label: string;
+    resolveDefaultPaths(env: NodeJS.ProcessEnv, platform: NodeJS.Platform, cwd: string): DefaultPathCandidate[];
+    load(path: string): Promise<NormalizedConfig>;
+    save(path: string, normalized: NormalizedConfig): Promise<SaveResult>;
+}
+
+declare const adapters: readonly IdeAdapter[];
+declare function getAdapter(id: string): IdeAdapter;
+
+type ClassificationKind = "add" | "unchanged" | "conflict";
+interface ClassifiedEntry {
+    name: string;
+    kind: ClassificationKind;
+    source: NormalizedMcpServer;
+    target?: NormalizedMcpServer;
+}
+/** Classifies each source entry relative to the target, by server name. */
+declare function classify(source: NormalizedConfig, target: NormalizedConfig): ClassifiedEntry[];
+
+/** Renders a +/- line diff between a conflicting entry's target and source definitions. */
+declare function renderConflictDiff(entry: ClassifiedEntry): string;
+/**
+ * Renders an editable merge scaffold for a conflicting entry: lines
+ * identical between target and source pass through unmarked, differing
+ * lines are wrapped in git-style conflict markers for the user to resolve
+ * by hand.
+ */
+declare function renderMergeScaffold(entry: ClassifiedEntry): string;
+
+type ConflictResolution = {
+    kind: "accept-target";
+} | {
+    kind: "accept-source";
+} | {
+    kind: "merge";
+    merged: NormalizedMcpServer;
+};
+type ConflictResolutions = Record<string, ConflictResolution>;
+/**
+ * Produces the merged config: every Add entry from source, every Conflict
+ * entry per its resolution, every Unchanged entry as-is, and every
+ * target-only entry left untouched.
+ */
+declare function applyMerge(target: NormalizedConfig, classifications: ClassifiedEntry[], resolutions: ConflictResolutions): NormalizedConfig;
+
+interface CategorySummary {
+    count: number;
+    names: string[];
+}
+interface MigrationSummary {
+    added: CategorySummary;
+    unchanged: CategorySummary;
+    conflicts: {
+        total: number;
+        acceptTarget: CategorySummary;
+        acceptSource: CategorySummary;
+        merged: CategorySummary;
+    };
+}
+declare function summarize(classifications: ClassifiedEntry[], resolutions: ConflictResolutions): MigrationSummary;
+/** True when a migration has nothing to add and nothing to resolve. */
+declare function isNoOp(classifications: ClassifiedEntry[]): boolean;
+
+export { type BackupPreference, type BackupVersion, type ClassificationKind, type ClassifiedEntry, type ConflictResolution, type ConflictResolutions, type DefaultPathCandidate, type DroppedExtraFields, type ExtraFields, type IdeAdapter, type MigrationSummary, type NormalizedConfig, type NormalizedMcpServer, type SaveResult, type Transport, type VersionsStore, adapters, appendVersion, applyMerge, areServersEqual, classify, defaultSettingsPath, getAdapter, isNoOp, readVersionsStore, renderConflictDiff, renderMergeScaffold, setBackupLocation, setPreference, summarize };

package/dist/index.js

@@ -0,0 +1,32 @@
+import {
+  adapters,
+  appendVersion,
+  applyMerge,
+  areServersEqual,
+  classify,
+  defaultSettingsPath,
+  getAdapter,
+  isNoOp,
+  readVersionsStore,
+  renderConflictDiff,
+  renderMergeScaffold,
+  setBackupLocation,
+  setPreference,
+  summarize
+} from "./chunk-E2A5N2LX.js";
+export {
+  adapters,
+  appendVersion,
+  applyMerge,
+  areServersEqual,
+  classify,
+  defaultSettingsPath,
+  getAdapter,
+  isNoOp,
+  readVersionsStore,
+  renderConflictDiff,
+  renderMergeScaffold,
+  setBackupLocation,
+  setPreference,
+  summarize
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "mcp-config-migrator",
+  "version": "0.1.0",
+  "description": "Interactively migrate and merge MCP server configurations between VS Code, Cursor, and Claude Code.",
+  "keywords": [
+    "mcp",
+    "cli",
+    "vscode",
+    "cursor",
+    "claude-code"
+  ],
+  "homepage": "https://github.com/industrial-curiosity/mcp-config-migrator#readme",
+  "bugs": {
+    "url": "https://github.com/industrial-curiosity/mcp-config-migrator/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/industrial-curiosity/mcp-config-migrator.git"
+  },
+  "author": "Industrial Curiosity",
+  "type": "module",
+  "bin": {
+    "mcp-config-migrator": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "local": "npm run build && node dist/cli.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.5.1",
+    "diff": "^9.0.0",
+    "jsonc-parser": "^3.3.1"
+  },
+  "devDependencies": {
+    "@types/diff": "^7.0.2",
+    "@types/node": "^22.10.2",
+    "eslint": "^10.5.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.18.2",
+    "vitest": "^4.1.9"
+  }
+}