editor-profile-sync 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 sbetav
+
+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,133 @@
+# editor-profile-sync
+
+Cross-platform CLI to share your VS Code-based editor profile between editors.
+
+You can sync:
+- extensions
+- snippets
+- `settings.json`
+
+## Requirements
+
+- **Node.js** 18 or newer
+- **npm** (comes with Node.js)
+- At least one [supported editor](#supported-editors) installed, with its CLI on your PATH (e.g. `code`, `cursor`)
+
+## Install
+
+Clone this repo, then install dependencies:
+
+```bash
+npm install
+```
+
+## Usage
+
+From the project folder:
+
+```bash
+npm start
+```
+
+or:
+
+```bash
+node index.js
+```
+
+After linking (`npm link` in this folder), run from anywhere:
+
+```bash
+editor-profile-sync
+```
+
+### Options
+
+| Option            | Description         |
+| ----------------- | ------------------- |
+| `-h`, `--help`    | Show help message   |
+| `-v`, `--version` | Show version number |
+
+## How it works
+
+1. Detect installed editors (only editors with CLI on PATH are shown).
+2. Choose a source editor.
+3. Choose what to share:
+   - `Extensions`
+   - `settings.json`
+   - `Snippets`
+4. Choose mode(s) for selected item types:
+   - Extensions:
+     - Install on top of existing (additive)
+     - Exact sync (replace all extensions)
+   - Snippets:
+     - Merge (source snippets override key conflicts in matching snippet files)
+     - Replace (target snippets folder is replaced)
+5. Choose one or more target editors.
+6. Run sync.
+
+### Settings merge behavior
+
+For `settings.json`, each target is merged as:
+
+```js
+const merged = {
+  ...targetSettings,
+  ...sourceSettings
+}
+```
+
+What this means:
+- Shared/source settings win on key conflicts.
+- Existing unrelated target settings stay.
+- Editor-specific keys are preserved unless your source uses the same key.
+
+Example:
+
+Target:
+
+```json
+{
+  "terminal.integrated.fontSize": 14
+}
+```
+
+Source:
+
+```json
+{
+  "editor.formatOnSave": true
+}
+```
+
+Result:
+
+```json
+{
+  "terminal.integrated.fontSize": 14,
+  "editor.formatOnSave": true
+}
+```
+
+## Supported editors
+
+These editors are currently supported:
+
+| Editor      | CLI command   |
+| ----------- | ------------- |
+| Antigravity | `antigravity` |
+| Cursor      | `cursor`      |
+| Kiro        | `kiro`        |
+| Trae        | `trae`        |
+| VS Code     | `code`        |
+| Windsurf    | `windsurf`    |
+
+Each editor must be installed and available in your terminal (e.g. `code`, `cursor`).
+
+## Generated files
+
+- `extensions.txt` is created when syncing extensions and contains the exported source extension IDs.
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import ora from "ora";
+import chalk from "chalk";
+import {
+  EDITORS,
+  EXTENSION_MODES,
+  EXTENSIONS_FILE,
+  SNIPPET_MODES,
+  SYNC_ITEMS,
+} from "./lib/constants.js";
+import { isEditorInstalled } from "./lib/editor-cli.js";
+import {
+  exportExtensions,
+  readExtensionsFile,
+  syncExtensions,
+} from "./lib/extensions-sync.js";
+import { getSettingsPath, getSnippetsPath } from "./lib/profile-paths.js";
+import { readSourceSettings, syncSettings } from "./lib/settings-sync.js";
+import { syncSnippets } from "./lib/snippets-sync.js";
+import {
+  promptExtensionMode,
+  promptSnippetMode,
+  promptSourceEditor,
+  promptSyncItems,
+  promptTargetEditors,
+} from "./lib/prompts.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, "package.json"), "utf-8"));
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+  ${pkg.name} v${pkg.version}
+  ${pkg.description}
+
+  Usage: ${Object.keys(pkg.bin)[0]} [options]
+
+  Options:
+    -h, --help      Show this help message
+    -v, --version   Show version number
+`);
+    return;
+  }
+
+  if (args.includes("--version") || args.includes("-v")) {
+    console.log(pkg.version);
+    return;
+  }
+
+  console.log("\n  Editor profile sync\n");
+
+  const detectSpinner = ora({
+    text: "Detecting installed editors...",
+    color: "cyan",
+  }).start();
+
+  const availableEditors = EDITORS.filter((editor) =>
+    isEditorInstalled(editor),
+  );
+
+  if (availableEditors.length === 0) {
+    detectSpinner.fail("No supported editors found on PATH.");
+    console.log(
+      chalk.yellow(
+        "\n  Install at least one supported editor and make sure its CLI is on your PATH.\n",
+      ),
+    );
+    process.exit(1);
+  }
+
+  detectSpinner.succeed(
+    `Found ${availableEditors.length} editor(s): ${availableEditors
+      .map((e) => e.name)
+      .join(", ")}`,
+  );
+  console.log("");
+
+  const sourceId = await promptSourceEditor(availableEditors);
+  const sourceEditor = availableEditors.find((e) => e.id === sourceId);
+
+  const syncItems = await promptSyncItems(SYNC_ITEMS, chalk);
+
+  let extensionMode = "additive";
+  if (syncItems.includes("extensions")) {
+    extensionMode = await promptExtensionMode(EXTENSION_MODES);
+  }
+
+  let snippetMode = "merge";
+  if (syncItems.includes("snippets")) {
+    snippetMode = await promptSnippetMode(SNIPPET_MODES);
+  }
+
+  const targetChoices = availableEditors
+    .filter((e) => e.id !== sourceId)
+    .map((e) => ({ name: e.name, value: e.id }));
+
+  if (targetChoices.length === 0) {
+    console.log(
+      chalk.yellow("\n  No other installed editors found to sync to.\n"),
+    );
+    process.exit(1);
+  }
+
+  const targetIds = await promptTargetEditors(targetChoices, chalk);
+  const targetEditors = availableEditors.filter((e) =>
+    targetIds.includes(e.id),
+  );
+
+  const cwd = process.cwd();
+  const extensionsPath = join(cwd, EXTENSIONS_FILE);
+
+  let desiredExtensions = [];
+  if (syncItems.includes("extensions")) {
+    const exportSpinner = ora({
+      text: `Exporting extensions from ${sourceEditor.name}...`,
+      color: "cyan",
+    }).start();
+    try {
+      await exportExtensions(sourceEditor, extensionsPath);
+      desiredExtensions = readExtensionsFile(extensionsPath);
+      exportSpinner.succeed(
+        `Exported ${desiredExtensions.length} extensions to ${EXTENSIONS_FILE}`,
+      );
+    } catch (err) {
+      exportSpinner.fail("Extension export failed");
+      console.error("  Error:", err.message, "\n");
+      process.exit(1);
+    }
+  }
+
+  let sourceSettings = {};
+  if (syncItems.includes("settings")) {
+    try {
+      sourceSettings = readSourceSettings(getSettingsPath(sourceEditor));
+    } catch (err) {
+      console.error(`  ${err.message}\n`);
+      process.exit(1);
+    }
+  }
+
+  let sourceSnippetsDir = "";
+  if (syncItems.includes("snippets")) {
+    sourceSnippetsDir = getSnippetsPath(sourceEditor);
+    if (!existsSync(sourceSnippetsDir)) {
+      console.error(
+        `  Source snippets folder not found: ${sourceSnippetsDir}\n`,
+      );
+      process.exit(1);
+    }
+  }
+
+  console.log("");
+
+  for (const editor of targetEditors) {
+    try {
+      console.log(chalk.bold(editor.name));
+
+      if (syncItems.includes("extensions")) {
+        const spinner = ora({
+          text: `${chalk.bold(editor.name)}: Installing extensions...`,
+          color: "cyan",
+        }).start();
+        const result = await syncExtensions(
+          editor,
+          desiredExtensions,
+          extensionMode,
+          (i, extensionId) => {
+            spinner.text = `${chalk.bold(editor.name)}: [${i + 1}/${desiredExtensions.length}] Installing ${extensionId}`;
+          },
+        );
+        const parts = [chalk.green(`${result.synced} extensions synced`)];
+        if (result.failed.length > 0) {
+          parts.push(chalk.red(`${result.failed.length} failed`));
+        }
+        spinner.succeed(`${chalk.bold(editor.name)}: ${parts.join(", ")}`);
+        if (result.failed.length > 0) {
+          console.log(
+            `      ${chalk.red("Failed:")} ${result.failed.join(", ")}`,
+          );
+        }
+      }
+
+      if (syncItems.includes("settings")) {
+        const spinner = ora({
+          text: `${chalk.bold(editor.name)}: Syncing settings.json...`,
+          color: "cyan",
+        }).start();
+        try {
+          const targetPath = getSettingsPath(editor, { createIfMissing: true });
+          const merged = syncSettings(sourceSettings, targetPath);
+          spinner.succeed(
+            `${chalk.bold(editor.name)}: settings.json synced (${Object.keys(merged).length} keys)`,
+          );
+        } catch (err) {
+          spinner.fail(
+            `${chalk.bold(editor.name)}: settings sync failed (${err.message})`,
+          );
+        }
+      }
+
+      if (syncItems.includes("snippets")) {
+        const spinner = ora({
+          text: `${chalk.bold(editor.name)}: Syncing snippets (${snippetMode})...`,
+          color: "cyan",
+        }).start();
+        try {
+          const targetSnippetsDir = getSnippetsPath(editor, {
+            createIfMissing: true,
+          });
+          const fileCount = syncSnippets(
+            sourceSnippetsDir,
+            targetSnippetsDir,
+            snippetMode,
+          );
+          spinner.succeed(
+            `${chalk.bold(editor.name)}: snippets synced (${fileCount} file${fileCount === 1 ? "" : "s"}, ${snippetMode})`,
+          );
+        } catch (err) {
+          spinner.fail(
+            `${chalk.bold(editor.name)}: snippets sync failed (${err.message})`,
+          );
+        }
+      }
+
+      console.log("");
+    } catch (err) {
+      console.log("  ", editor.name, "error:", err.message, "\n");
+    }
+  }
+
+  console.log(chalk.green("✔ Sync complete.\n"));
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/lib/constants.js

@@ -0,0 +1,66 @@
+export const EXTENSIONS_FILE = "extensions.txt";
+export const SETTINGS_FILE = "settings.json";
+export const SNIPPETS_DIR = "snippets";
+
+// Sorted alphabetically by display name.
+export const EDITORS = [
+  { id: "antigravity", name: "Antigravity", cmd: "antigravity" },
+  { id: "cursor", name: "Cursor", cmd: "cursor" },
+  { id: "kiro", name: "Kiro", cmd: "kiro" },
+  { id: "trae", name: "Trae", cmd: "trae" },
+  { id: "code", name: "VS Code", cmd: "code" },
+  { id: "windsurf", name: "Windsurf", cmd: "windsurf" },
+];
+
+export const EXTENSION_MODES = [
+  {
+    value: "additive",
+    name: "Install extensions on top of existing (Recommended)",
+    short: "Additive",
+  },
+  {
+    value: "strict",
+    name: "Exact sync (Replace all extensions)",
+    short: "Strict",
+  },
+];
+
+export const SNIPPET_MODES = [
+  {
+    value: "merge",
+    name: "Merge snippet files (Recommended)",
+    short: "Merge",
+  },
+  {
+    value: "replace",
+    name: "Replace all target snippets",
+    short: "Replace",
+  },
+];
+
+export const SYNC_ITEMS = [
+  {
+    value: "extensions",
+    name: "Extensions",
+    short: "Extensions",
+  },
+  {
+    value: "settings",
+    name: "settings.json",
+    short: "settings.json",
+  },
+  {
+    value: "snippets",
+    name: "Snippets",
+    short: "Snippets",
+  },
+];
+
+export const EDITOR_DATA_DIRS = {
+  antigravity: ["Antigravity"],
+  code: ["Code", "Code - OSS"],
+  cursor: ["Cursor"],
+  kiro: ["Kiro"],
+  trae: ["Trae"],
+  windsurf: ["Windsurf"],
+};

package/lib/editor-cli.js

@@ -0,0 +1,78 @@
+import { execSync, spawn } from "child_process";
+
+export function isEditorInstalled(editor) {
+  const cmd = process.platform === "win32" ? "where" : "which";
+  try {
+    execSync(`${cmd} ${editor.cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function escapeShellArg(arg) {
+  const s = String(arg);
+  return s.includes(" ") || s.includes('"') ? `"${s.replace(/"/g, '""')}"` : s;
+}
+
+function runEditorCmdAsync(editor, args, options = {}) {
+  const { ignoreError = false } = options;
+  const cmdString = [editor.cmd, ...args.map(escapeShellArg)].join(" ");
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmdString, [], {
+      shell: true,
+      stdio: ["inherit", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    if (child.stdout) {
+      child.stdout.on("data", (d) => {
+        stdout += d.toString();
+      });
+    }
+
+    if (child.stderr) {
+      child.stderr.on("data", (d) => {
+        stderr += d.toString();
+      });
+    }
+
+    child.on("close", (code) => {
+      if (code === 0) resolve(stdout);
+      else if (ignoreError) resolve(null);
+      else reject(new Error(stderr || `Exit ${code}`));
+    });
+
+    child.on("error", (err) => reject(err));
+  });
+}
+
+export async function getInstalledExtensions(editor) {
+  const out = await runEditorCmdAsync(editor, ["--list-extensions"], {
+    ignoreError: true,
+  });
+  if (out == null) return null;
+  return out
+    .split(/\r?\n/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+export async function installExtension(editor, extensionId) {
+  const out = await runEditorCmdAsync(
+    editor,
+    ["--install-extension", extensionId],
+    {
+      ignoreError: true,
+    },
+  );
+  return out !== null;
+}
+
+export function uninstallExtension(editor, extensionId) {
+  const cmd = [editor.cmd, "--uninstall-extension", extensionId].join(" ");
+  execSync(cmd, { stdio: "ignore" });
+}

package/lib/extensions-sync.js

@@ -0,0 +1,61 @@
+import { readFileSync, writeFileSync } from "fs";
+import {
+  getInstalledExtensions,
+  installExtension,
+  uninstallExtension,
+} from "./editor-cli.js";
+
+export async function exportExtensions(sourceEditor, filePath) {
+  const list = await getInstalledExtensions(sourceEditor);
+  if (list == null) {
+    throw new Error(`${sourceEditor.name} CLI not found or failed.`);
+  }
+
+  const sorted = [...list].sort();
+  writeFileSync(
+    filePath,
+    sorted.join("\n") + (sorted.length ? "\n" : ""),
+    "utf-8",
+  );
+
+  return sorted;
+}
+
+export function readExtensionsFile(filePath) {
+  const content = readFileSync(filePath, "utf-8");
+  return content
+    .split(/\r?\n/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+export async function syncExtensions(editor, desired, mode, onProgress) {
+  const current = await getInstalledExtensions(editor);
+  if (current == null) {
+    throw new Error(`${editor.name} CLI not found or failed.`);
+  }
+
+  if (mode === "strict") {
+    const toRemove = current.filter((id) => !desired.includes(id));
+    for (const extensionId of toRemove) {
+      try {
+        uninstallExtension(editor, extensionId);
+      } catch {
+        // Keep going; failures are naturally reflected when reinstalling.
+      }
+    }
+  }
+
+  let synced = 0;
+  const failed = [];
+
+  for (let i = 0; i < desired.length; i++) {
+    const extensionId = desired[i];
+    if (onProgress) onProgress(i, extensionId);
+    const ok = await installExtension(editor, extensionId);
+    if (ok) synced++;
+    else failed.push(extensionId);
+  }
+
+  return { synced, failed };
+}

package/lib/profile-paths.js

@@ -0,0 +1,36 @@
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { EDITOR_DATA_DIRS, SETTINGS_FILE, SNIPPETS_DIR } from "./constants.js";
+
+function getConfigBaseDir() {
+  if (process.platform === "win32") {
+    return process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+  }
+  if (process.platform === "darwin") {
+    return join(homedir(), "Library", "Application Support");
+  }
+  return process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+}
+
+function getEditorUserDir(editor, { createIfMissing = false } = {}) {
+  const base = getConfigBaseDir();
+  const names = EDITOR_DATA_DIRS[editor.id] || [editor.name];
+  const candidates = names.map((name) => join(base, name, "User"));
+  const existing = candidates.find((p) => existsSync(p));
+  const selected = existing || candidates[0];
+
+  if (createIfMissing) {
+    mkdirSync(selected, { recursive: true });
+  }
+
+  return selected;
+}
+
+export function getSettingsPath(editor, options = {}) {
+  return join(getEditorUserDir(editor, options), SETTINGS_FILE);
+}
+
+export function getSnippetsPath(editor, options = {}) {
+  return join(getEditorUserDir(editor, options), SNIPPETS_DIR);
+}

package/lib/prompts.js

@@ -0,0 +1,96 @@
+import inquirer from "inquirer";
+import CheckboxPrompt from "inquirer/lib/prompts/checkbox.js";
+
+class CleanCheckboxPrompt extends CheckboxPrompt {
+  constructor(questions, rl, answers) {
+    super(questions, rl, answers);
+    this.dontShowHints = true;
+  }
+}
+
+let isRegistered = false;
+
+function ensurePromptRegistered() {
+  if (isRegistered) return;
+  inquirer.registerPrompt("clean-checkbox", CleanCheckboxPrompt);
+  isRegistered = true;
+}
+
+const CHECKBOX_HINT =
+  "(Press <space> to select, <a> to toggle all, <enter> to continue)";
+
+export async function promptSourceEditor(availableEditors) {
+  ensurePromptRegistered();
+  const answer = await inquirer.prompt([
+    {
+      type: "list",
+      name: "sourceId",
+      message: "Share from:",
+      choices: availableEditors.map((e) => ({ name: e.name, value: e.id })),
+      pageSize: 10,
+    },
+  ]);
+  return answer.sourceId;
+}
+
+export async function promptSyncItems(syncItems, chalk) {
+  ensurePromptRegistered();
+  const answer = await inquirer.prompt([
+    {
+      type: "clean-checkbox",
+      name: "selectedItems",
+      message: `Share: ${chalk.dim(CHECKBOX_HINT)}`,
+      choices: syncItems,
+      validate: (v) => (v.length ? true : "Select at least one item."),
+    },
+  ]);
+  return answer.selectedItems;
+}
+
+export async function promptExtensionMode(extensionModes) {
+  const answer = await inquirer.prompt([
+    {
+      type: "list",
+      name: "extensionMode",
+      message: "Extension mode:",
+      choices: extensionModes.map((m) => ({
+        name: m.name,
+        value: m.value,
+        short: m.short,
+      })),
+      default: "additive",
+    },
+  ]);
+  return answer.extensionMode;
+}
+
+export async function promptSnippetMode(snippetModes) {
+  const answer = await inquirer.prompt([
+    {
+      type: "list",
+      name: "snippetMode",
+      message: "Snippet mode:",
+      choices: snippetModes.map((m) => ({
+        name: m.name,
+        value: m.value,
+        short: m.short,
+      })),
+      default: "merge",
+    },
+  ]);
+  return answer.snippetMode;
+}
+
+export async function promptTargetEditors(targetChoices, chalk) {
+  ensurePromptRegistered();
+  const answer = await inquirer.prompt([
+    {
+      type: "clean-checkbox",
+      name: "targetIds",
+      message: `Sync to: ${chalk.dim(CHECKBOX_HINT)}`,
+      choices: targetChoices,
+      validate: (v) => (v.length ? true : "Select at least one editor."),
+    },
+  ]);
+  return answer.targetIds;
+}

package/lib/settings-sync.js

@@ -0,0 +1,74 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import { parse, printParseErrorCode } from "jsonc-parser";
+
+function isPlainObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value);
+}
+
+function readJsonFile(filePath, fallback = {}) {
+  if (!existsSync(filePath)) return fallback;
+  const raw = readFileSync(filePath, "utf-8");
+  const errors = [];
+  const parsed = parse(raw, errors, {
+    allowTrailingComma: true,
+    disallowComments: false,
+  });
+
+  if (errors.length > 0) {
+    const first = errors[0];
+    const position = getLineAndColumn(raw, first.offset);
+    throw new Error(
+      `${filePath} parse error (${printParseErrorCode(first.error)}) at line ${position.line}, column ${position.column}.`,
+    );
+  }
+
+  if (!isPlainObject(parsed)) {
+    throw new Error(`${filePath} must be a JSON object.`);
+  }
+  return parsed;
+}
+
+function getLineAndColumn(text, offset) {
+  let line = 1;
+  let column = 1;
+  for (let i = 0; i < offset; i++) {
+    if (text[i] === "\n") {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return { line, column };
+}
+
+function writeJsonFile(filePath, data) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
+}
+
+export function readSourceSettings(sourcePath) {
+  if (!existsSync(sourcePath)) {
+    throw new Error(`Source settings not found: ${sourcePath}`);
+  }
+  return readJsonFile(sourcePath, {});
+}
+
+export function syncSettings(sourceSettings, targetPath) {
+  const targetSettings = readJsonFile(targetPath, {});
+  const merged = {
+    ...targetSettings,
+    ...sourceSettings,
+  };
+  writeJsonFile(targetPath, merged);
+  return merged;
+}
+
+export function readJsonObject(filePath, fallback = {}) {
+  return readJsonFile(filePath, fallback);
+}
+
+export function writeJsonObject(filePath, data) {
+  writeJsonFile(filePath, data);
+}

package/lib/snippets-sync.js

@@ -0,0 +1,68 @@
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  statSync,
+} from "fs";
+import { dirname, join } from "path";
+import { readJsonObject, writeJsonObject } from "./settings-sync.js";
+
+function listFilesRecursive(dirPath, prefix = "") {
+  if (!existsSync(dirPath)) return [];
+
+  const entries = readdirSync(dirPath);
+  const files = [];
+
+  for (const entry of entries) {
+    const rel = prefix ? join(prefix, entry) : entry;
+    const abs = join(dirPath, entry);
+    const st = statSync(abs);
+    if (st.isDirectory()) {
+      files.push(...listFilesRecursive(abs, rel));
+    } else if (st.isFile()) {
+      files.push(rel);
+    }
+  }
+
+  return files;
+}
+
+function mergeSnippetFile(sourcePath, targetPath) {
+  const source = readJsonObject(sourcePath, {});
+  const target = readJsonObject(targetPath, {});
+  const merged = {
+    ...target,
+    ...source,
+  };
+  writeJsonObject(targetPath, merged);
+}
+
+export function syncSnippets(sourceDir, targetDir, mode) {
+  if (!existsSync(sourceDir)) {
+    throw new Error(`Source snippets folder not found: ${sourceDir}`);
+  }
+
+  if (mode === "replace") {
+    rmSync(targetDir, { recursive: true, force: true });
+    mkdirSync(dirname(targetDir), { recursive: true });
+    cpSync(sourceDir, targetDir, { recursive: true, force: true });
+    return listFilesRecursive(targetDir).length;
+  }
+
+  const sourceFiles = listFilesRecursive(sourceDir);
+  for (const relPath of sourceFiles) {
+    const sourcePath = join(sourceDir, relPath);
+    const targetPath = join(targetDir, relPath);
+    mkdirSync(dirname(targetPath), { recursive: true });
+
+    if (sourcePath.toLowerCase().endsWith(".json")) {
+      mergeSnippetFile(sourcePath, targetPath);
+    } else {
+      cpSync(sourcePath, targetPath, { force: true });
+    }
+  }
+
+  return sourceFiles.length;
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "editor-profile-sync",
+  "version": "1.0.0",
+  "description": "Cross-platform extensions, settings.json, and snippets sync for VS Code-based editors",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "editor-profile-sync": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "run": "node index.js"
+  },
+  "keywords": [
+    "vscode",
+    "cursor",
+    "windsurf",
+    "trae",
+    "kiro",
+    "extensions",
+    "settings",
+    "snippets",
+    "profile",
+    "sync",
+    "export",
+    "editor-profile-sync"
+  ],
+  "author": "sbetav",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "inquirer": "^9.2.22",
+    "jsonc-parser": "^3.3.1",
+    "ora": "^9.3.0"
+  }
+}