vibe-config-sync 0.0.1

package/README.md

@@ -0,0 +1,127 @@
+# vibe-sync
+
+Sync AI coding tool configurations across machines via Git. Currently supports Claude Code (`~/.claude/`).
+
+## Problem
+
+When using AI coding tools on multiple machines, configurations like skills, commands, agents, plugins, and user preferences need to be manually replicated on each machine.
+
+## What Gets Synced
+
+| Content | Description |
+|---------|-------------|
+| `settings.json` | Plugin enable/disable flags |
+| `CLAUDE.md` | User preferences and workflow guidelines |
+| `skills/` | Skill definitions (SKILL.md + references + templates) |
+| `commands/` | Custom slash commands |
+| `agents/` | Agent definitions |
+| `plugins/installed_plugins.json` | Plugin registry (machine paths stripped) |
+| `plugins/known_marketplaces.json` | Plugin marketplace sources (machine paths stripped) |
+
+**Not synced** (machine-specific / ephemeral / large): `plugins/cache/`, `projects/`, `telemetry/`, `session-env/`, `plans/`, `todos/`, `debug/`, `history.jsonl`, etc.
+
+## Prerequisites
+
+- Node.js 18+
+- `git`
+- `claude` CLI (only needed for `--reinstall-plugins`)
+
+## Installation
+
+```bash
+npm install -g vibe-sync
+```
+
+## Quick Start
+
+### Machine A (first time setup)
+
+```bash
+vibe-sync init          # Initialize and connect to a Git remote
+vibe-sync push          # Export configs and push to remote
+```
+
+### Machine B (import)
+
+```bash
+vibe-sync init                      # Initialize and pull from remote
+vibe-sync pull                      # Pull and import configs
+vibe-sync pull --reinstall-plugins  # Pull, import, and reinstall plugins
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `vibe-sync init` | Initialize sync repository and connect to Git remote |
+| `vibe-sync export` | Collect configs from `~/.claude/` into sync repo |
+| `vibe-sync import` | Restore configs from sync repo to `~/.claude/` |
+| `vibe-sync import --reinstall-plugins` | Restore + reinstall all plugins |
+| `vibe-sync status` | Show diff between local and synced configs |
+| `vibe-sync push` | export + git commit + git push |
+| `vibe-sync pull` | git pull + import |
+| `vibe-sync pull --reinstall-plugins` | git pull + import + reinstall all plugins |
+
+## Daily Workflow
+
+```bash
+# After changing configs on Machine A
+vibe-sync push
+
+# On Machine B, pull latest
+vibe-sync pull
+```
+
+## How It Works
+
+- **Export** copies config files into `~/.vibe-sync/data/`, stripping machine-specific paths from plugin JSON files. Skills that are symlinks are resolved and their actual contents are copied.
+
+- **Import** restores files from `~/.vibe-sync/data/` to `~/.claude/`, and optionally reinstalls plugins via `claude plugin install`.
+
+- **Backup** is created automatically at `~/.vibe-sync/backups/claude/<timestamp>/` before every import.
+
+## Sync Strategy
+
+The overall strategy is **last-write-wins with no conflict detection**. There is no field-level merge — the most recent import overwrites the target.
+
+### Files (`settings.json`, `CLAUDE.md`)
+
+Whole-file overwrite. The sync repo version replaces the local version entirely.
+
+### Directories (`skills/`, `commands/`, `agents/`)
+
+Directory-level merge + file-level overwrite:
+
+| Scenario | Behavior |
+|----------|----------|
+| Repo has `skills/foo/`, local does not | `foo/` is added |
+| Both have `skills/foo/SKILL.md` | Repo version overwrites local |
+| Local has `skills/bar/`, repo does not | `bar/` is **kept** (not deleted) |
+| Repo's `skills/foo/` is missing a file that local has | Local file is **kept** |
+
+In short: new content is added, existing content is overwritten, but nothing is deleted from the local side.
+
+### Symlinked Skills
+
+- **Export**: symlinks are resolved via `realpathSync` and the actual file contents are copied — the symlink itself is not preserved
+- **Import**: copied as regular directories, no symlink recreation needed. This ensures skills work across machines regardless of the original symlink target path
+
+### Plugin JSON
+
+Whole-file overwrite, same as `settings.json`. No key-level merge between local and repo versions.
+
+### What This Means in Practice
+
+- If both machines modify different configs and then sync, the machine that runs `import` last will lose its local changes (a timestamped backup exists at `~/.vibe-sync/backups/claude/` for manual recovery)
+- Deleted files/skills on one machine will **not** be deleted on the other — only additions and modifications propagate
+- Symlinked skills are resolved and copied as regular directories, so the synced version is a standalone snapshot independent of the original symlink target
+
+## Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `CLAUDE_HOME` | Override Claude config directory | `~/.claude` |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,606 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/core/config.ts
+import fs from "fs-extra";
+import os from "os";
+import path from "path";
+var CLAUDE_HOME = process.env.CLAUDE_HOME ?? path.join(os.homedir(), ".claude");
+var SYNC_DIR = path.join(os.homedir(), ".vibe-sync");
+var BACKUP_BASE = path.join(SYNC_DIR, "backups", "claude");
+function getConfigDir() {
+  return path.join(SYNC_DIR, "data");
+}
+function isInitialized() {
+  return fs.existsSync(path.join(SYNC_DIR, ".git"));
+}
+var SYNC_FILES = ["settings.json", "CLAUDE.md"];
+var SYNC_DIRS = ["commands", "agents"];
+
+// src/commands/export.ts
+import fs4 from "fs-extra";
+import path4 from "path";
+
+// src/core/logger.ts
+import pc from "picocolors";
+function logInfo(...args) {
+  console.log(pc.blue("[INFO]"), ...args);
+}
+function logOk(...args) {
+  console.log(pc.green("[OK]"), ...args);
+}
+function logWarn(...args) {
+  console.log(pc.yellow("[WARN]"), ...args);
+}
+function logError(...args) {
+  console.error(pc.red("[ERROR]"), ...args);
+}
+
+// src/core/fs-utils.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+function copyDirClean(src, dest) {
+  fs2.copySync(src, dest, { overwrite: true });
+  removeDsStore(dest);
+}
+function removeDsStore(dir) {
+  if (!fs2.existsSync(dir)) return;
+  const entries = fs2.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry.name);
+    if (entry.name === ".DS_Store") {
+      fs2.removeSync(fullPath);
+    } else if (entry.isDirectory() && !entry.isSymbolicLink()) {
+      removeDsStore(fullPath);
+    }
+  }
+}
+function readJsonSafe(filePath) {
+  try {
+    return fs2.readJsonSync(filePath);
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      logWarn(`Failed to parse ${filePath}: ${err.message}`);
+    }
+    return null;
+  }
+}
+function writeJsonSafe(filePath, data) {
+  fs2.ensureDirSync(path2.dirname(filePath));
+  fs2.writeJsonSync(filePath, data, { spaces: 2 });
+}
+
+// src/core/sanitize.ts
+function sanitizePlugins(data) {
+  const result = structuredClone(data);
+  for (const entries of Object.values(result.plugins ?? {})) {
+    for (const entry of entries) {
+      delete entry.installPath;
+    }
+  }
+  return result;
+}
+function sanitizeMarketplaces(data) {
+  const result = structuredClone(data);
+  for (const entry of Object.values(result)) {
+    delete entry.installLocation;
+  }
+  return result;
+}
+
+// src/core/skills.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+function exportSkills(srcDir, destDir) {
+  if (!fs3.existsSync(srcDir)) {
+    logWarn("Skills directory not found:", srcDir);
+    return;
+  }
+  fs3.ensureDirSync(destDir);
+  const entries = fs3.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const name = entry.name;
+    const fullPath = path3.join(srcDir, name);
+    if (entry.isSymbolicLink()) {
+      const realPath = fs3.realpathSync(fullPath);
+      copyDirClean(realPath, path3.join(destDir, name));
+      logInfo(`Exported skill (resolved symlink): ${name}`);
+    } else if (entry.isDirectory()) {
+      copyDirClean(fullPath, path3.join(destDir, name));
+      logInfo(`Exported skill: ${name}`);
+    }
+  }
+  logOk("Skills exported");
+}
+function importSkills(srcDir, destDir) {
+  if (!fs3.existsSync(srcDir)) return;
+  fs3.ensureDirSync(destDir);
+  const entries = fs3.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const src = path3.join(srcDir, entry.name);
+      const dest = path3.join(destDir, entry.name);
+      fs3.copySync(src, dest, { overwrite: true });
+      logInfo(`Imported skill: ${entry.name}`);
+    }
+  }
+}
+
+// src/commands/export.ts
+function cmdExport() {
+  const configDir = getConfigDir();
+  const pluginsDir = path4.join(configDir, "plugins");
+  fs4.ensureDirSync(pluginsDir);
+  for (const file of SYNC_FILES) {
+    const src = path4.join(CLAUDE_HOME, file);
+    if (fs4.existsSync(src)) {
+      fs4.copySync(src, path4.join(configDir, file));
+      logInfo(`Exported: ${file}`);
+    } else {
+      logWarn(`Not found: ${file}`);
+    }
+  }
+  for (const dir of SYNC_DIRS) {
+    const src = path4.join(CLAUDE_HOME, dir);
+    if (fs4.existsSync(src)) {
+      copyDirClean(src, path4.join(configDir, dir));
+      logInfo(`Exported: ${dir}/`);
+    } else {
+      logWarn(`Not found: ${dir}/`);
+    }
+  }
+  exportSkills(
+    path4.join(CLAUDE_HOME, "skills"),
+    path4.join(configDir, "skills")
+  );
+  const installedPlugins = readJsonSafe(
+    path4.join(CLAUDE_HOME, "plugins", "installed_plugins.json")
+  );
+  if (installedPlugins) {
+    writeJsonSafe(
+      path4.join(pluginsDir, "installed_plugins.json"),
+      sanitizePlugins(installedPlugins)
+    );
+    logInfo("Exported: plugins/installed_plugins.json (sanitized)");
+  }
+  const marketplaces = readJsonSafe(
+    path4.join(CLAUDE_HOME, "plugins", "known_marketplaces.json")
+  );
+  if (marketplaces) {
+    writeJsonSafe(
+      path4.join(pluginsDir, "known_marketplaces.json"),
+      sanitizeMarketplaces(marketplaces)
+    );
+    logInfo("Exported: plugins/known_marketplaces.json (sanitized)");
+  }
+  logOk("Export complete");
+}
+
+// src/commands/import.ts
+import fs6 from "fs-extra";
+import path6 from "path";
+
+// src/core/backup.ts
+import fs5 from "fs-extra";
+import path5 from "path";
+function backupExisting() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").slice(0, 15);
+  const backupDir = path5.join(BACKUP_BASE, timestamp);
+  fs5.ensureDirSync(backupDir);
+  for (const file of SYNC_FILES) {
+    const src = path5.join(CLAUDE_HOME, file);
+    if (fs5.existsSync(src)) {
+      fs5.copySync(src, path5.join(backupDir, file));
+    }
+  }
+  for (const dir of SYNC_DIRS) {
+    const src = path5.join(CLAUDE_HOME, dir);
+    if (fs5.existsSync(src)) {
+      fs5.copySync(src, path5.join(backupDir, dir));
+    }
+  }
+  const skillsDir = path5.join(CLAUDE_HOME, "skills");
+  if (fs5.existsSync(skillsDir)) {
+    fs5.copySync(skillsDir, path5.join(backupDir, "skills"));
+  }
+  const pluginsDir = path5.join(CLAUDE_HOME, "plugins");
+  for (const file of ["installed_plugins.json", "known_marketplaces.json"]) {
+    const src = path5.join(pluginsDir, file);
+    if (fs5.existsSync(src)) {
+      fs5.ensureDirSync(path5.join(backupDir, "plugins"));
+      fs5.copySync(src, path5.join(backupDir, "plugins", file));
+    }
+  }
+  logOk(`Backup created: ${backupDir}`);
+  return backupDir;
+}
+
+// src/core/plugins.ts
+import { execFileSync } from "child_process";
+function isNonNullObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function execClaude(args) {
+  try {
+    execFileSync("claude", args, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isClaudeAvailable() {
+  try {
+    execFileSync("claude", ["--version"], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function reinstallPlugins(marketplacesFile, pluginsFile, settingsFile) {
+  if (!isClaudeAvailable()) {
+    logError("claude CLI not found. Cannot reinstall plugins.");
+    return;
+  }
+  logInfo("Phase 1: Adding plugin marketplaces...");
+  const marketplaces = readJsonSafe(marketplacesFile);
+  if (isNonNullObject(marketplaces)) {
+    for (const [name, entry] of Object.entries(marketplaces)) {
+      if (!isNonNullObject(entry)) continue;
+      const source = entry.source;
+      if (!isNonNullObject(source)) continue;
+      let arg;
+      if (source.source === "github" && source.repo) {
+        arg = `github:${source.repo}`;
+      } else if (source.url) {
+        arg = source.url;
+      } else {
+        logWarn(`Unknown marketplace source for ${name}`);
+        continue;
+      }
+      if (execClaude(["plugin", "marketplace", "add", arg])) {
+        logOk(`Added marketplace: ${name}`);
+      } else {
+        logWarn(`Failed to add marketplace: ${name}`);
+      }
+    }
+  }
+  logInfo("Phase 2: Installing plugins...");
+  const plugins = readJsonSafe(pluginsFile);
+  if (isNonNullObject(plugins) && isNonNullObject(plugins.plugins)) {
+    for (const key of Object.keys(plugins.plugins)) {
+      if (execClaude(["plugin", "install", key])) {
+        logOk(`Installed plugin: ${key}`);
+      } else {
+        logWarn(`Failed to install plugin: ${key}`);
+      }
+    }
+  }
+  logInfo("Phase 3: Enabling plugins...");
+  const settings = readJsonSafe(settingsFile);
+  if (isNonNullObject(settings) && isNonNullObject(settings.enabledPlugins)) {
+    for (const [key, enabled] of Object.entries(settings.enabledPlugins)) {
+      if (!enabled) continue;
+      if (execClaude(["plugin", "enable", key])) {
+        logOk(`Enabled plugin: ${key}`);
+      } else {
+        logWarn(`Failed to enable plugin: ${key}`);
+      }
+    }
+  }
+  logOk("Plugin reinstallation complete");
+}
+
+// src/commands/import.ts
+function cmdImport(options = {}) {
+  const configDir = getConfigDir();
+  if (!fs6.existsSync(configDir)) {
+    throw new Error(
+      `Config directory not found: ${configDir}
+Run "vibe-sync export" first or "vibe-sync pull"`
+    );
+  }
+  backupExisting();
+  for (const file of SYNC_FILES) {
+    const src = path6.join(configDir, file);
+    if (fs6.existsSync(src)) {
+      fs6.ensureDirSync(path6.dirname(path6.join(CLAUDE_HOME, file)));
+      fs6.copySync(src, path6.join(CLAUDE_HOME, file));
+      logInfo(`Imported: ${file}`);
+    }
+  }
+  for (const dir of SYNC_DIRS) {
+    const src = path6.join(configDir, dir);
+    if (fs6.existsSync(src)) {
+      fs6.copySync(src, path6.join(CLAUDE_HOME, dir), { overwrite: true });
+      logInfo(`Imported: ${dir}/`);
+    }
+  }
+  importSkills(
+    path6.join(configDir, "skills"),
+    path6.join(CLAUDE_HOME, "skills")
+  );
+  const pluginsSrc = path6.join(configDir, "plugins");
+  const pluginsDest = path6.join(CLAUDE_HOME, "plugins");
+  for (const file of ["installed_plugins.json", "known_marketplaces.json"]) {
+    const src = path6.join(pluginsSrc, file);
+    if (fs6.existsSync(src)) {
+      fs6.ensureDirSync(pluginsDest);
+      fs6.copySync(src, path6.join(pluginsDest, file));
+      logInfo(`Imported: plugins/${file}`);
+    }
+  }
+  if (options.reinstallPlugins) {
+    reinstallPlugins(
+      path6.join(pluginsDest, "known_marketplaces.json"),
+      path6.join(pluginsDest, "installed_plugins.json"),
+      path6.join(CLAUDE_HOME, "settings.json")
+    );
+  }
+  logOk("Import complete");
+}
+
+// src/commands/status.ts
+import path7 from "path";
+
+// src/core/diff.ts
+import fs7 from "fs-extra";
+import { execFileSync as execFileSync2 } from "child_process";
+import pc2 from "picocolors";
+function showDiff(localPath, repoPath, label) {
+  if (!fs7.existsSync(localPath) && !fs7.existsSync(repoPath)) {
+    return false;
+  }
+  if (!fs7.existsSync(localPath)) {
+    console.log(pc2.yellow(`  ${label}: exists in repo but not locally`));
+    return true;
+  }
+  if (!fs7.existsSync(repoPath)) {
+    console.log(pc2.yellow(`  ${label}: exists locally but not in repo`));
+    return true;
+  }
+  const isDir = fs7.statSync(localPath).isDirectory();
+  try {
+    const args = isDir ? ["-rq", localPath, repoPath] : ["-q", localPath, repoPath];
+    execFileSync2("diff", args, { stdio: "pipe" });
+    return false;
+  } catch {
+    console.log(pc2.yellow(`  ${label}: differs`));
+    if (!isDir) {
+      try {
+        const output = execFileSync2(
+          "diff",
+          ["--color=auto", localPath, repoPath],
+          { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+        );
+        if (output) console.log(output);
+      } catch (e) {
+        const err = e;
+        if (err.stdout) console.log(err.stdout);
+      }
+    }
+    return true;
+  }
+}
+
+// src/commands/status.ts
+function cmdStatus() {
+  const configDir = getConfigDir();
+  let hasDiff = false;
+  for (const file of SYNC_FILES) {
+    const local = path7.join(CLAUDE_HOME, file);
+    const repo = path7.join(configDir, file);
+    if (showDiff(local, repo, file)) {
+      hasDiff = true;
+    }
+  }
+  for (const dir of SYNC_DIRS) {
+    const local = path7.join(CLAUDE_HOME, dir);
+    const repo = path7.join(configDir, dir);
+    if (showDiff(local, repo, `${dir}/`)) {
+      hasDiff = true;
+    }
+  }
+  const localSkills = path7.join(CLAUDE_HOME, "skills");
+  const repoSkills = path7.join(configDir, "skills");
+  if (showDiff(localSkills, repoSkills, "skills/")) {
+    hasDiff = true;
+  }
+  for (const file of ["installed_plugins.json", "known_marketplaces.json"]) {
+    const local = path7.join(CLAUDE_HOME, "plugins", file);
+    const repo = path7.join(configDir, "plugins", file);
+    if (showDiff(local, repo, `plugins/${file}`)) {
+      hasDiff = true;
+    }
+  }
+  if (!hasDiff) {
+    logOk("No differences found");
+  }
+}
+
+// src/core/git.ts
+import { simpleGit } from "simple-git";
+function createGit(baseDir) {
+  return simpleGit({ baseDir });
+}
+async function ensureGitRepo(git) {
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) {
+    await git.init();
+    logInfo("Initialized git repository");
+  }
+}
+async function hasRemote(git) {
+  try {
+    const remotes = await git.getRemotes();
+    return remotes.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function commitAndPush(git) {
+  await ensureGitRepo(git);
+  await git.add("-A");
+  const status = await git.status();
+  if (status.isClean()) {
+    logInfo("No changes to commit");
+  } else {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", "_");
+    const msg = `sync: update claude configs ${timestamp}`;
+    await git.commit(msg);
+    logOk(`Committed: ${msg}`);
+  }
+  if (await hasRemote(git)) {
+    const branch = (await git.branchLocal()).current || "main";
+    await git.push(["-u", "origin", branch]);
+    logOk("Pushed to remote");
+  } else {
+    logWarn("No remote configured. Run: git remote add origin <url>");
+  }
+  return !status.isClean();
+}
+async function pullFromRemote(git) {
+  if (!await hasRemote(git)) {
+    throw new Error("No remote configured. Run: git remote add origin <url>");
+  }
+  await git.pull();
+  logOk("Pulled from remote");
+}
+
+// src/commands/push.ts
+async function cmdPush() {
+  cmdExport();
+  const git = createGit(SYNC_DIR);
+  await commitAndPush(git);
+}
+
+// src/commands/pull.ts
+async function cmdPull(options = {}) {
+  const git = createGit(SYNC_DIR);
+  await pullFromRemote(git);
+  cmdImport({ reinstallPlugins: options.reinstallPlugins });
+}
+
+// src/commands/init.ts
+import fs8 from "fs-extra";
+import path8 from "path";
+import readline from "readline/promises";
+function createReadline() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+async function cmdInit() {
+  if (isInitialized()) {
+    const git = createGit(SYNC_DIR);
+    const remotes = await git.getRemotes(true);
+    const origin = remotes.find((r) => r.name === "origin");
+    if (origin) {
+      logInfo(`Current remote: ${origin.refs.fetch}`);
+    } else {
+      logWarn("No remote configured");
+    }
+    const rl2 = createReadline();
+    try {
+      const url = await rl2.question("? New Git remote URL (leave empty to keep current): ");
+      const trimmedUrl = url.trim();
+      if (!trimmedUrl) {
+        logInfo("Remote unchanged");
+        return;
+      }
+      const gitUrlPattern = /^(https?:\/\/|git@|ssh:\/\/|git:\/\/).+/;
+      if (!gitUrlPattern.test(trimmedUrl)) {
+        logError("Invalid Git URL format. Expected https://, git@, ssh://, or git:// URL");
+        return;
+      }
+      if (origin) {
+        await git.remote(["set-url", "origin", trimmedUrl]);
+      } else {
+        await git.addRemote("origin", trimmedUrl);
+      }
+      logOk(`Remote updated: ${trimmedUrl}`);
+    } finally {
+      rl2.close();
+    }
+    return;
+  }
+  console.log("");
+  console.log("Welcome to vibe-sync! Let's set up config synchronization.");
+  console.log("");
+  const rl = createReadline();
+  try {
+    const url = await rl.question("? Git remote URL: ");
+    const trimmedUrl = url.trim();
+    if (!trimmedUrl) {
+      logError("URL cannot be empty");
+      return;
+    }
+    const gitUrlPattern = /^(https?:\/\/|git@|ssh:\/\/|git:\/\/).+/;
+    if (!gitUrlPattern.test(trimmedUrl)) {
+      logError("Invalid Git URL format. Expected https://, git@, ssh://, or git:// URL");
+      return;
+    }
+    fs8.ensureDirSync(SYNC_DIR);
+    fs8.writeFileSync(
+      path8.join(SYNC_DIR, ".gitignore"),
+      ".DS_Store\nThumbs.db\n"
+    );
+    const git = createGit(SYNC_DIR);
+    await git.init();
+    logOk("Initialized git repository");
+    await git.addRemote("origin", trimmedUrl);
+    logOk(`Remote added: ${trimmedUrl}`);
+    try {
+      await git.pull("origin", "main");
+      logOk("Pulled existing data from remote");
+    } catch {
+      try {
+        await git.pull("origin", "master");
+        logOk("Pulled existing data from remote");
+      } catch {
+        logInfo("No existing data on remote (new repository)");
+      }
+    }
+    console.log("");
+    logOk("Setup complete!");
+    console.log("");
+    console.log("  vibe-sync push   Export configs and push to remote");
+    console.log("  vibe-sync pull   Pull from remote and import configs");
+    console.log("  vibe-sync status Show diff between local and synced");
+    console.log("");
+  } finally {
+    rl.close();
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("vibe-sync").description("Sync AI coding tool configurations across machines via git").version("0.0.1").action(async () => {
+  if (!isInitialized()) {
+    await cmdInit();
+  } else {
+    cmdStatus();
+  }
+});
+program.command("init").description("Initialize sync repository").action(cmdInit);
+program.command("export").description("Export configs from ~/.claude/ to sync repo").action(cmdExport);
+program.command("import").description("Import configs from sync repo to ~/.claude/").option("--reinstall-plugins", "Reinstall plugins via claude CLI").action((opts) => {
+  cmdImport({ reinstallPlugins: opts.reinstallPlugins });
+});
+program.command("status").description("Show diff between local and synced configs").action(cmdStatus);
+program.command("push").description("Export + git commit + git push").action(cmdPush);
+program.command("pull").description("Git pull + import").option("--reinstall-plugins", "Reinstall plugins via claude CLI").action(async (opts) => {
+  await cmdPull({ reinstallPlugins: opts.reinstallPlugins });
+});
+async function run() {
+  try {
+    await program.parseAsync();
+  } catch (err) {
+    logError(err instanceof Error ? err.message : "An unexpected error occurred");
+    process.exit(1);
+  }
+}
+run();

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "vibe-config-sync",
+  "version": "0.0.1",
+  "description": "Cross-platform CLI tool to sync AI coding tool configurations across machines via git",
+  "type": "module",
+  "bin": {
+    "vibe-sync": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "sync",
+    "config",
+    "cli"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^13.1.0",
+    "fs-extra": "^11.2.0",
+    "picocolors": "^1.1.1",
+    "simple-git": "^3.27.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.10.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  }
+}