memoir-cli 1.4.3 → 1.4.5

package/README.md

@@ -6,7 +6,7 @@
 [![npm version](https://img.shields.io/npm/v/memoir-cli.svg?style=flat-square)](https://npmjs.org/package/memoir-cli)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
 
-*Never lose your AI's context again. Sync Gemini CLI, Claude Code, and more across all your devices instantly.*
+*Never lose your AI's context again. Sync and translate your AI memory across every device and tool.*
 
 </div>
 
@@ -22,9 +22,9 @@ Suddenly, you're starting from scratch. Your AI's "memory" is trapped in hidden
 
 ## 🚀 The Solution
 
-`memoir` is a zero-friction CLI tool that seamlessly extracts, backs up, and restores your AI's memory across any computer. You bring your own storage (a private GitHub repo or an iCloud/Dropbox folder), and `memoir` handles the rest safely and securely.
+`memoir` is a zero-friction CLI that extracts, backs up, restores, and **translates** your AI's memory across any computer and any tool. Bring your own storage (a private GitHub repo or an iCloud/Dropbox folder), and `memoir` handles the rest.
 
-No locked-in SaaS, no lost context, no complex shell scripts.
+No locked-in SaaS, no lost context, no complex shell scripts. Switch from Claude to Gemini in one command.
 
 ### Supported Integrations
 - [x] **Gemini CLI**
@@ -72,6 +72,97 @@ memoir restore
 memoir pull
 ```
 
+### 4. Translate Between Tools
+Switch AI tools without losing context. Memoir uses Gemini AI to intelligently rewrite your memory files for any supported tool:
+
+```bash
+memoir migrate --from claude --to gemini
+# or run interactively:
+memoir migrate
+```
+
+Your Claude instructions become a proper `GEMINI.md` — not a copy-paste, but a real translation that follows each tool's conventions.
+
+---
+
+## 📖 All Commands
+
+| Command | What it does |
+|---------|-------------|
+| `memoir init` | Setup wizard — pick GitHub or local folder, upload or download |
+| `memoir push` | Extract all AI tool configs, back up to GitHub/local |
+| `memoir restore` | Pull backup down, restore missing files (non-destructive) |
+| `memoir status` | Show which AI tools are detected on this machine |
+| `memoir view` | Preview backup contents with diffs against local |
+| `memoir migrate` | Translate memory between tools via Gemini AI |
+
+---
+
+## 🎯 Common Workflows
+
+### New laptop setup
+```bash
+# Old machine — save everything
+memoir init    # → Upload → GitHub
+
+# New machine — restore everything
+memoir init    # → Download → GitHub
+# All your .claude/, .gemini/, .cursorrules configs restored in 30 seconds
+```
+
+### Switch from Claude to Gemini (or any tool)
+```bash
+memoir migrate --from claude --to gemini
+```
+Your CLAUDE.md + Claude memory files get intelligently rewritten as a proper GEMINI.md — not a copy-paste, but a real translation that follows Gemini's conventions.
+
+### Keep your whole team in sync
+```bash
+# Team lead writes CLAUDE.md, then generates for everyone else:
+memoir migrate --from claude --to cursor
+memoir migrate --from claude --to copilot
+memoir migrate --from claude --to codex
+```
+
+### Fan out to every tool at once
+```bash
+memoir migrate --from claude --to gemini
+memoir migrate --from claude --to codex
+memoir migrate --from claude --to cursor
+memoir migrate --from claude --to windsurf
+memoir migrate --from claude --to aider
+```
+Use one tool as the source of truth, propagate to all others.
+
+### Preview before committing
+```bash
+memoir migrate --from gemini --to claude --dry-run
+# Shows translated output but writes nothing
+```
+
+### Protect existing files
+```bash
+memoir migrate --from claude --to gemini
+# → "GEMINI.md already exists."
+# → Overwrite / Append / Skip
+# Append adds a dated separator so you keep your existing instructions
+```
+
+### Daily sync across machines
+```bash
+# End of day
+memoir push
+
+# Next morning, different machine
+memoir pull
+```
+
+### Check what's on this machine
+```bash
+memoir status
+# Shows checkmarks for every detected AI tool and their config locations
+```
+
 ---
 
 ## 🔒 Security First
@@ -82,12 +173,12 @@ Our specialized adapters intelligently filter your directories. We **only** sync
 
 ---
 
-## 🗺️ Roadmap: The Future of Data Portability
-
-We believe developers shouldn't be locked into a single AI ecosystem.
+## 🗺️ Roadmap
 
-**Coming in v2.0: The Migration Engine**
-Currently, `memoir` backs up your files exactly as they are. Soon, you will be able to run `memoir migrate --from claude --to gemini`. The CLI will automatically translate your Claude Code instructions into Gemini CLI facts, allowing you to fluidly swap AI providers without losing a drop of context.
+**What's next:**
+- Team sharing — sync a shared memory repo across your whole team
+- Auto-detect new AI tools as they appear
+- Two-way merge — combine memories from multiple tools into one
 
 ---
 

package/bin/memoir.js

@@ -8,8 +8,11 @@ import { pushCommand } from '../src/commands/push.js';
 import { restoreCommand } from '../src/commands/restore.js';
 import { statusCommand } from '../src/commands/status.js';
 import { viewCommand } from '../src/commands/view.js';
+import { migrateCommand } from '../src/commands/migrate.js';
+import { createRequire } from 'module';
 
-const VERSION = '1.2.0';
+const require = createRequire(import.meta.url);
+const { version: VERSION } = require('../package.json');
 
 // Custom help banner
 program.addHelpText('beforeAll', '\n' + boxen(
@@ -88,15 +91,17 @@ program
 
 program
   .command('migrate')
-  .description('Translate memory between AI providers')
-  .action(() => {
-    console.log('\n' + boxen(
-      gradient.pastel('  memoir migrate  ') + '\n\n' +
-      chalk.white('Instantly translate your context between') + '\n' +
-      chalk.white('Claude, Gemini, Codex, and more.') + '\n\n' +
-      chalk.cyan.bold('Coming soon.'),
-      { padding: 1, borderStyle: 'round', borderColor: 'yellow', align: 'center' }
-    ) + '\n');
+  .description('Translate memory between AI tools (Claude, Gemini, Codex, Cursor, etc.)')
+  .option('--from <tool>', 'Source tool (claude, gemini, codex, cursor, copilot, windsurf, aider)')
+  .option('--to <tool>', 'Target tool (claude, gemini, codex, cursor, copilot, windsurf, aider, all)')
+  .option('--dry-run', 'Preview translation without writing files')
+  .action(async (options) => {
+    try {
+      await migrateCommand(options);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error during migration:'), err.message);
+      process.exit(1);
+    }
   });
 
 program.parse();

package/package.json

@@ -1,12 +1,20 @@
 {
   "name": "memoir-cli",
-  "version": "1.4.3",
-  "description": "Your AI remembers everything. Sync it everywhere.",
+  "version": "1.4.5",
+  "description": "Sync and translate AI memory across devices and tools. Back up Claude, Gemini, Codex, Cursor, Copilot, Windsurf, and Aider configs. Migrate instructions between AI coding assistants with one command.",
   "main": "src/index.js",
   "type": "module",
   "bin": {
     "memoir": "bin/memoir.js"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/camgitt/memoir.git"
+  },
+  "homepage": "https://github.com/camgitt/memoir#readme",
+  "bugs": {
+    "url": "https://github.com/camgitt/memoir/issues"
+  },
   "scripts": {
     "start": "node bin/memoir.js",
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -16,14 +24,30 @@
     "cli",
     "sync",
     "memory",
-    "memoir",
-    "gemini",
-    "claude",
     "backup",
-    "restore"
+    "restore",
+    "migrate",
+    "translate",
+    "claude",
+    "gemini",
+    "codex",
+    "cursor",
+    "copilot",
+    "windsurf",
+    "aider",
+    "ai-memory",
+    "ai-tools",
+    "dotfiles",
+    "developer-tools",
+    "claude-code",
+    "gemini-cli",
+    "openai",
+    "ai-assistant",
+    "coding-assistant",
+    "context-sync"
   ],
-  "author": "",
-  "license": "ISC",
+  "author": "camgitt",
+  "license": "MIT",
   "dependencies": {
     "boxen": "^7.1.1",
     "chalk": "^5.3.0",
@@ -31,6 +55,7 @@
     "fs-extra": "^11.2.0",
     "gradient-string": "^3.0.0",
     "inquirer": "^9.2.15",
+    "memoir-cli": "^1.4.4",
     "open": "^11.0.0",
     "ora": "^7.0.1"
   }

package/src/adapters/index.js

@@ -11,6 +11,7 @@ const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
 export const adapters = [
   {
     name: 'Gemini CLI',
+    icon: '🔵',
     source: path.join(home, '.gemini'),
     filter: (src) => {
       const basename = path.basename(src);
@@ -20,6 +21,7 @@ export const adapters = [
   },
   {
     name: 'Claude CLI',
+    icon: '🟣',
     source: path.join(home, '.claude'),
     filter: (src) => {
       const basename = path.basename(src);
@@ -28,6 +30,7 @@ export const adapters = [
   },
   {
     name: 'OpenAI Codex',
+    icon: '🟢',
     source: path.join(home, '.codex'),
     filter: (src) => {
       const basename = path.basename(src);
@@ -37,6 +40,7 @@ export const adapters = [
   },
   {
     name: 'Cursor',
+    icon: '⚡',
     source: isWin
       ? path.join(appData, 'Cursor', 'User')
       : path.join(home, 'Library', 'Application Support', 'Cursor', 'User'),
@@ -48,6 +52,7 @@ export const adapters = [
   },
   {
     name: 'GitHub Copilot',
+    icon: '🐙',
     source: isWin
       ? path.join(appData, 'GitHub Copilot')
       : path.join(home, '.config', 'github-copilot'),
@@ -59,6 +64,7 @@ export const adapters = [
   },
   {
     name: 'Windsurf',
+    icon: '🏄',
     source: isWin
       ? path.join(appData, 'Windsurf', 'User')
       : path.join(home, 'Library', 'Application Support', 'Windsurf', 'User'),
@@ -70,6 +76,7 @@ export const adapters = [
   },
   {
     name: 'Aider',
+    icon: '🔧',
     source: home,
     customExtract: true,
     files: ['.aider.conf.yml', '.aider.system-prompt.md'],
@@ -77,33 +84,96 @@ export const adapters = [
   }
 ];
 
+async function countFiles(dir) {
+  let count = 0;
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      count += await countFiles(path.join(dir, entry.name));
+    } else {
+      count++;
+    }
+  }
+  return count;
+}
+
+async function dirSize(dir) {
+  let size = 0;
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      size += await dirSize(fullPath);
+    } else {
+      const stat = await fs.stat(fullPath);
+      size += stat.size;
+    }
+  }
+  return size;
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}kb`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}mb`;
+}
+
 export async function extractMemories(stagingDir, spinner) {
   let foundAny = false;
+  const results = [];
 
   for (const adapter of adapters) {
     if (adapter.customExtract) {
-      // Handle tools with individual files (e.g. Aider)
       const dest = path.join(stagingDir, adapter.name.toLowerCase().replace(/ /g, '-'));
       let foundFile = false;
+      let fileCount = 0;
+
       for (const file of adapter.files) {
         const filePath = path.join(adapter.source, file);
         if (await fs.pathExists(filePath)) {
           if (!foundFile) {
-            spinner.text = `Found ${chalk.cyan(adapter.name)} config... copying to staging`;
+            spinner.text = `${adapter.icon} Scanning ${chalk.cyan(adapter.name)}...`;
             await fs.ensureDir(dest);
             foundFile = true;
           }
           await fs.copy(filePath, path.join(dest, file));
+          fileCount++;
         }
       }
-      if (foundFile) foundAny = true;
+
+      if (foundFile) {
+        foundAny = true;
+        results.push({ adapter, fileCount, size: await dirSize(dest) });
+        spinner.text = `${adapter.icon} ${chalk.green(adapter.name)} ${chalk.gray(`(${fileCount} files)`)}`;
+      }
     } else if (await fs.pathExists(adapter.source)) {
-      spinner.text = `Found ${chalk.cyan(adapter.name)} memory... copying to staging`;
+      spinner.text = `${adapter.icon} Scanning ${chalk.cyan(adapter.name)}...`;
       const dest = path.join(stagingDir, adapter.name.toLowerCase().replace(/ /g, '-'));
       await fs.ensureDir(dest);
       await fs.copy(adapter.source, dest, { filter: adapter.filter });
+
+      const fileCount = await countFiles(dest);
+      const size = await dirSize(dest);
       foundAny = true;
+      results.push({ adapter, fileCount, size });
+      spinner.text = `${adapter.icon} ${chalk.green(adapter.name)} ${chalk.gray(`(${fileCount} files, ${formatSize(size)})`)}`;
+    }
+  }
+
+  // Print tree after scanning
+  if (results.length > 0) {
+    spinner.stop();
+    console.log('');
+    console.log(chalk.white.bold('  Detected AI tools:\n'));
+    for (let i = 0; i < results.length; i++) {
+      const r = results[i];
+      const isLast = i === results.length - 1;
+      const branch = isLast ? '  └─' : '  ├─';
+      const detail = chalk.gray(` ${r.fileCount} files, ${formatSize(r.size)}`);
+      console.log(`${branch} ${r.adapter.icon} ${chalk.cyan(r.adapter.name)}${detail}`);
     }
+    console.log('');
+    spinner.start(chalk.gray('Uploading...'));
   }
 
   return foundAny;

package/src/commands/init.js

@@ -2,17 +2,27 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import boxen from 'boxen';
 import gradient from 'gradient-string';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { saveConfig } from '../config.js';
 import { pushCommand } from './push.js';
 import { restoreCommand } from './restore.js';
 
 function getGitUsername() {
   try {
-    return execSync('git config --global user.name', { encoding: 'utf8' }).trim();
+    return execFileSync('git', ['config', '--global', 'user.name'], { encoding: 'utf8' }).trim();
   } catch { return ''; }
 }
 
+function getGitHubUsername() {
+  try {
+    // Try gh CLI first
+    return execFileSync('gh', ['api', 'user', '--jq', '.login'], { encoding: 'utf8' }).trim();
+  } catch {
+    // Fall back to git config
+    return getGitUsername();
+  }
+}
+
 export async function initCommand() {
   console.log('');
   console.log(boxen(
@@ -22,7 +32,7 @@ export async function initCommand() {
   ));
   console.log('');
 
-  const gitUser = getGitUsername();
+  const detectedUser = getGitHubUsername();
 
   const { direction, provider } = await inquirer.prompt([
     {
@@ -57,27 +67,46 @@ export async function initCommand() {
     }]);
     config.localPath = localPath;
   } else {
-    const { username, repo } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'username',
-        message: 'GitHub username:',
-        validate: (input) => input.trim() ? true : 'Required'
-      },
-      {
+    // Pre-fill username if detected, just ask for repo name
+    const prompts = [];
+
+    if (detectedUser) {
+      console.log(chalk.gray(`  GitHub user: ${chalk.cyan(detectedUser)}`));
+      prompts.push({
         type: 'input',
         name: 'repo',
-        message: 'Repo name:',
+        message: `Repo name (${detectedUser}/???):`,
         default: 'ai-memory',
         validate: (input) => input.trim() ? true : 'Required'
-      }
-    ]);
+      });
+    } else {
+      prompts.push(
+        {
+          type: 'input',
+          name: 'username',
+          message: 'GitHub username:',
+          validate: (input) => input.trim() ? true : 'Required'
+        },
+        {
+          type: 'input',
+          name: 'repo',
+          message: 'Repo name:',
+          default: 'ai-memory',
+          validate: (input) => input.trim() ? true : 'Required'
+        }
+      );
+    }
+
+    const answers = await inquirer.prompt(prompts);
+    const username = (answers.username || detectedUser).trim();
+    const repo = answers.repo.trim();
 
-    config.gitRepo = `https://github.com/${username.trim()}/${repo.trim()}.git`;
+    config.gitRepo = `https://github.com/${username}/${repo}.git`;
+    console.log(chalk.gray(`  → ${config.gitRepo}\n`));
   }
 
   await saveConfig(config);
-  console.log(chalk.green('Saved!\n'));
+  console.log(chalk.green('✔ Saved!\n'));
 
   if (direction === 'upload') {
     await pushCommand();

package/src/commands/migrate.js

@@ -0,0 +1,241 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import boxen from 'boxen';
+import gradient from 'gradient-string';
+import { getProfile, getProfileKeys, getProfileChoices } from '../tools/index.js';
+import { resolveApiKey, translateMemory } from '../migrate/translator.js';
+
+const TOOL_ICONS = {
+  claude: '🟣', gemini: '🔵', codex: '🟢', cursor: '⚡',
+  copilot: '🐙', windsurf: '🏄', aider: '🔧'
+};
+
+function toolLabel(key) {
+  return `${TOOL_ICONS[key] || '●'} ${getProfile(key)?.name || key}`;
+}
+
+async function translateToTarget(targetKey, sourceFiles, sourceProfile, apiKey, dryRun) {
+  const targetProfile = getProfile(targetKey);
+  const spinner = ora();
+  const translated = [];
+  const failed = [];
+
+  for (const file of sourceFiles) {
+    const basename = path.basename(file.filePath);
+    spinner.start(chalk.cyan(`  ${TOOL_ICONS[targetKey] || '●'} Translating ${basename} → ${targetProfile.name}...`));
+
+    try {
+      const result = await translateMemory(file.content, sourceProfile, targetProfile, apiKey);
+      translated.push({ source: file, result });
+      spinner.succeed(chalk.green(`  ${TOOL_ICONS[targetKey] || '✔'} ${basename} → ${targetProfile.name}`));
+    } catch (err) {
+      failed.push({ source: file, error: err.message });
+      spinner.fail(chalk.red(`  ✖ ${basename} → ${targetProfile.name}: ${err.message}`));
+    }
+  }
+
+  if (translated.length === 0) {
+    return { targetKey, translated: 0, failed: failed.length, written: false };
+  }
+
+  // Combine content
+  let finalContent;
+  if (translated.length === 1) {
+    finalContent = translated[0].result;
+  } else {
+    finalContent = translated.map((t, i) => {
+      const header = `# From ${path.basename(t.source.filePath)}`;
+      return i === 0 ? `${header}\n\n${t.result}` : `\n\n${header}\n\n${t.result}`;
+    }).join('');
+  }
+
+  if (dryRun) {
+    return { targetKey, translated: translated.length, failed: failed.length, written: false, content: finalContent };
+  }
+
+  // Write output
+  const targetPath = targetProfile.targetPath();
+  let writeMode = 'write';
+
+  if (await fs.pathExists(targetPath)) {
+    const { action } = await inquirer.prompt([{
+      type: 'list',
+      name: 'action',
+      message: `${TOOL_ICONS[targetKey]} ${path.basename(targetPath)} already exists.`,
+      choices: [
+        { name: 'Overwrite', value: 'overwrite' },
+        { name: 'Append', value: 'append' },
+        { name: 'Skip', value: 'skip' }
+      ]
+    }]);
+    writeMode = action;
+  }
+
+  if (writeMode === 'skip') {
+    return { targetKey, translated: translated.length, failed: failed.length, written: false };
+  }
+
+  await fs.ensureDir(path.dirname(targetPath));
+
+  if (writeMode === 'append') {
+    const existing = await fs.readFile(targetPath, 'utf-8');
+    const separator = `\n\n---\n<!-- Translated from ${sourceProfile.name} by memoir on ${new Date().toISOString().split('T')[0]} -->\n\n`;
+    await fs.writeFile(targetPath, existing + separator + finalContent);
+  } else {
+    await fs.writeFile(targetPath, finalContent);
+  }
+
+  return { targetKey, translated: translated.length, failed: failed.length, written: true, path: targetPath };
+}
+
+export async function migrateCommand(options = {}) {
+  let { from, to, dryRun } = options;
+
+  // 1. Pick source tool
+  if (!from) {
+    const answer = await inquirer.prompt([{
+      type: 'list',
+      name: 'from',
+      message: 'Translate from:',
+      choices: getProfileChoices().map(c => ({ ...c, name: `${TOOL_ICONS[c.value] || '●'} ${c.name}` }))
+    }]);
+    from = answer.from;
+  }
+
+  // 2. Pick target tool(s)
+  let targets = [];
+  if (to === 'all') {
+    targets = getProfileKeys().filter(k => k !== from);
+  } else if (to) {
+    targets = [to];
+  } else {
+    const choices = [
+      { name: '🌐 All tools', value: '_all' },
+      ...getProfileChoices()
+        .filter(c => c.value !== from)
+        .map(c => ({ ...c, name: `${TOOL_ICONS[c.value] || '●'} ${c.name}` }))
+    ];
+    const answer = await inquirer.prompt([{
+      type: 'list',
+      name: 'to',
+      message: 'Translate to:',
+      choices
+    }]);
+    targets = answer.to === '_all'
+      ? getProfileKeys().filter(k => k !== from)
+      : [answer.to];
+  }
+
+  // Validate
+  const sourceProfile = getProfile(from);
+  if (!sourceProfile) {
+    console.log(chalk.red(`\nUnknown source tool: ${from}`));
+    console.log(chalk.gray(`Available: ${getProfileKeys().join(', ')}`));
+    return;
+  }
+  for (const t of targets) {
+    if (!getProfile(t)) {
+      console.log(chalk.red(`\nUnknown target tool: ${t}`));
+      console.log(chalk.gray(`Available: ${getProfileKeys().join(', ')}`));
+      return;
+    }
+  }
+  if (targets.includes(from)) {
+    console.log(chalk.yellow('\nSource and target are the same tool.'));
+    return;
+  }
+
+  // 3. Resolve API key
+  const apiKey = await resolveApiKey(inquirer);
+
+  // 4. Discover source files
+  const sourceFiles = sourceProfile.discover();
+
+  if (sourceFiles.length === 0) {
+    console.log(chalk.yellow(`\nNo ${sourceProfile.name} memory files found.`));
+    console.log(chalk.gray('Make sure you\'re in the right directory or that the tool has been configured.'));
+    return;
+  }
+
+  // 5. Show source files
+  console.log('');
+  console.log(boxen(
+    `${TOOL_ICONS[from]} ${chalk.bold(sourceProfile.name)} ${chalk.gray('→')} ${targets.map(t => TOOL_ICONS[t]).join(' ')}\n\n` +
+    sourceFiles.map(f => {
+      const display = f.filePath.replace(os.homedir(), '~');
+      const size = chalk.gray(`(${(f.content.length / 1024).toFixed(1)}kb)`);
+      return `  ${chalk.cyan('◆')} ${display} ${size}`;
+    }).join('\n'),
+    { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
+  ));
+
+  const { proceed } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'proceed',
+    message: `Translate ${sourceFiles.length} file${sourceFiles.length > 1 ? 's' : ''} to ${targets.length} tool${targets.length > 1 ? 's' : ''}?`,
+    default: true
+  }]);
+
+  if (!proceed) {
+    console.log(chalk.gray('\nCancelled.'));
+    return;
+  }
+
+  console.log('');
+
+  // 6. Translate to each target
+  const results = [];
+  for (const targetKey of targets) {
+    const result = await translateToTarget(targetKey, sourceFiles, sourceProfile, apiKey, dryRun);
+    results.push(result);
+  }
+
+  // 7. Summary
+  const succeeded = results.filter(r => r.translated > 0);
+  const written = results.filter(r => r.written);
+  const totalFailed = results.reduce((sum, r) => sum + r.failed, 0);
+
+  console.log('');
+
+  if (dryRun) {
+    // Show preview for dry run
+    for (const r of succeeded) {
+      if (r.content) {
+        const preview = r.content.split('\n').slice(0, 10).join('\n');
+        console.log(chalk.cyan(`--- ${getProfile(r.targetKey).name} preview ---`));
+        console.log(chalk.gray(preview));
+        const totalLines = r.content.split('\n').length;
+        if (totalLines > 10) console.log(chalk.gray(`  ... (${totalLines - 10} more lines)`));
+        console.log('');
+      }
+    }
+    console.log(chalk.yellow('Dry run — no files written.\n'));
+    return;
+  }
+
+  // Build summary box
+  const summaryLines = results.map(r => {
+    const profile = getProfile(r.targetKey);
+    const icon = TOOL_ICONS[r.targetKey] || '●';
+    if (r.written) {
+      const display = r.path.replace(os.homedir(), '~');
+      return `  ${icon} ${chalk.green('✔')} ${profile.name} ${chalk.gray('→ ' + display)}`;
+    } else if (r.translated > 0) {
+      return `  ${icon} ${chalk.gray('⏭')} ${profile.name} ${chalk.gray('(skipped)')}`;
+    } else {
+      return `  ${icon} ${chalk.red('✖')} ${profile.name} ${chalk.gray('(failed)')}`;
+    }
+  }).join('\n');
+
+  console.log(boxen(
+    gradient.pastel('  Translated!  ') + '\n\n' +
+    summaryLines + '\n\n' +
+    chalk.gray(`${written.length} written, ${succeeded.length - written.length} skipped${totalFailed > 0 ? `, ${totalFailed} failed` : ''}`),
+    { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'green', dimBorder: true }
+  ));
+  console.log('');
+}

package/src/config.js

@@ -9,7 +9,11 @@ const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 
 export async function getConfig() {
   if (await fs.pathExists(CONFIG_FILE)) {
-    return fs.readJson(CONFIG_FILE);
+    try {
+      return await fs.readJson(CONFIG_FILE);
+    } catch {
+      return null;
+    }
   }
   return null;
 }
@@ -17,4 +21,19 @@ export async function getConfig() {
 export async function saveConfig(config) {
   await fs.ensureDir(CONFIG_DIR);
   await fs.writeJson(CONFIG_FILE, config, { spaces: 2 });
+  // Restrict permissions — config may contain API keys
+  if (process.platform !== 'win32') {
+    await fs.chmod(CONFIG_FILE, 0o600);
+  }
+}
+
+export async function getGeminiApiKey() {
+  const config = await getConfig();
+  return config?.geminiApiKey || process.env.GEMINI_API_KEY || null;
+}
+
+export async function saveGeminiApiKey(apiKey) {
+  const config = await getConfig() || {};
+  config.geminiApiKey = apiKey;
+  await saveConfig(config);
 }

package/src/migrate/profiles.js

@@ -0,0 +1,2 @@
+// Re-export from new plugin registry for backwards compatibility
+export { getProfile, getProfileKeys, getProfileChoices, profiles } from '../tools/index.js';

package/src/migrate/translator.js

@@ -0,0 +1,102 @@
+import { getConfig, saveConfig } from '../config.js';
+
+const GEMINI_API_URL = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent';
+const RETRYABLE_CODES = [429, 500, 502, 503];
+
+export async function resolveApiKey(inquirer) {
+  // 1. Check env var
+  if (process.env.GEMINI_API_KEY) {
+    return process.env.GEMINI_API_KEY;
+  }
+
+  // 2. Check memoir config
+  const config = await getConfig() || {};
+  if (config.geminiApiKey) {
+    return config.geminiApiKey;
+  }
+
+  // 3. Prompt user
+  const { apiKey } = await inquirer.prompt([{
+    type: 'password',
+    name: 'apiKey',
+    message: 'Gemini API key (free at aistudio.google.com):',
+    mask: '*',
+    validate: (v) => v.length > 10 || 'Please enter a valid API key'
+  }]);
+
+  // Save for next time
+  config.geminiApiKey = apiKey;
+  await saveConfig(config);
+
+  return apiKey;
+}
+
+async function callGeminiApi(prompt, apiKey) {
+  const response = await fetch(GEMINI_API_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-goog-api-key': apiKey
+    },
+    body: JSON.stringify({
+      contents: [{ parts: [{ text: prompt }] }],
+      generationConfig: {
+        temperature: 0.3,
+        maxOutputTokens: 8192
+      }
+    })
+  });
+
+  if (!response.ok) {
+    const err = await response.text();
+    if (response.status === 400 || response.status === 403) {
+      throw new Error('Invalid Gemini API key. Get a free key at https://aistudio.google.com');
+    }
+    if (RETRYABLE_CODES.includes(response.status)) {
+      const error = new Error(`Gemini API error (${response.status}): ${err}`);
+      error.retryable = true;
+      throw error;
+    }
+    throw new Error(`Gemini API error (${response.status}): ${err}`);
+  }
+
+  const data = await response.json();
+  const text = data?.candidates?.[0]?.content?.parts?.[0]?.text;
+
+  if (!text) {
+    throw new Error('Empty response from Gemini API');
+  }
+
+  return text.trim();
+}
+
+export async function translateMemory(content, sourceProfile, targetProfile, apiKey) {
+  const prompt = `You are an expert at translating AI coding assistant memory/instruction files between different tools.
+
+SOURCE TOOL: ${sourceProfile.name}
+SOURCE FORMAT: ${sourceProfile.format}
+
+TARGET TOOL: ${targetProfile.name}
+TARGET FORMAT: ${targetProfile.format}
+
+INSTRUCTIONS:
+- Translate the content below so it works perfectly as a ${targetProfile.name} instruction file.
+- Preserve ALL information, preferences, conventions, and context from the source.
+- Adapt the structure and phrasing to match ${targetProfile.name}'s conventions.
+- Remove any tool-specific references that don't apply to ${targetProfile.name}.
+- Keep the tone direct and instructional.
+- Output ONLY the translated content, no explanations or wrapping.
+
+SOURCE CONTENT:
+${content}`;
+
+  try {
+    return await callGeminiApi(prompt, apiKey);
+  } catch (err) {
+    if (err.retryable) {
+      await new Promise(r => setTimeout(r, 3000));
+      return await callGeminiApi(prompt, apiKey);
+    }
+    throw err;
+  }
+}

package/src/providers/index.js

@@ -2,66 +2,70 @@ import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
 import chalk from 'chalk';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
+
+function sanitizeUrl(url) {
+  // Reject URLs with shell metacharacters
+  if (/[`$;|&()<>!]/.test(url)) {
+    throw new Error('Repository URL contains invalid characters.');
+  }
+  return url;
+}
 
 export async function syncToLocal(config, stagingDir, spinner) {
   const destDir = config.localPath;
   if (!destDir) throw new Error('Local path is not configured.');
-  
-  // Expand tilde if user used it
+
   const resolvedDest = destDir.replace(/^~/, os.homedir());
-  
+
   spinner.text = `Syncing files to local directory: ${chalk.cyan(resolvedDest)}`;
   await fs.ensureDir(resolvedDest);
-  
+
   await fs.copy(stagingDir, resolvedDest);
   spinner.succeed(chalk.green('Sync complete! ') + chalk.gray(`(Saved to ${resolvedDest})`));
 }
 
 export async function syncToGit(config, stagingDir, spinner) {
-  const repoUrl = config.gitRepo;
+  const repoUrl = sanitizeUrl(config.gitRepo);
   if (!repoUrl) throw new Error('Git repository is not configured.');
-  
+
   spinner.text = `Authenticating and syncing with Git remote: ${chalk.cyan(repoUrl)}`;
-  
-  // Clone existing repo to preserve history, then replace contents
+
   const gitDir = path.join(os.tmpdir(), `memoir-git-${Date.now()}`);
   await fs.ensureDir(gitDir);
 
   try {
     try {
-      execSync(`git clone --depth 10 ${repoUrl} .`, { cwd: gitDir, stdio: 'ignore' });
-      // Remove old files so deleted configs don't persist
+      execFileSync('git', ['clone', '--depth', '1', repoUrl, '.'], { cwd: gitDir, stdio: 'ignore' });
       const files = await fs.readdir(gitDir);
       for (const f of files) {
         if (f !== '.git') await fs.remove(path.join(gitDir, f));
       }
     } catch {
-      // Repo is empty or doesn't exist yet — init fresh
-      execSync('git init', { cwd: gitDir, stdio: 'ignore' });
-      execSync('git branch -m main', { cwd: gitDir, stdio: 'ignore' });
+      execFileSync('git', ['init'], { cwd: gitDir, stdio: 'ignore' });
+      execFileSync('git', ['branch', '-m', 'main'], { cwd: gitDir, stdio: 'ignore' });
     }
 
-    // Copy staged memories into the git dir
     await fs.copy(stagingDir, gitDir);
 
-    execSync('git add -A', { cwd: gitDir, stdio: 'ignore' });
-    execSync('git config user.name "memoir"', { cwd: gitDir, stdio: 'ignore' });
-    execSync('git config user.email "bot@memoir.dev"', { cwd: gitDir, stdio: 'ignore' });
+    execFileSync('git', ['add', '-A'], { cwd: gitDir, stdio: 'ignore' });
+    execFileSync('git', ['config', 'user.name', 'memoir'], { cwd: gitDir, stdio: 'ignore' });
+    execFileSync('git', ['config', 'user.email', 'bot@memoir.dev'], { cwd: gitDir, stdio: 'ignore' });
 
     const timestamp = new Date().toISOString().split('T')[0];
     try {
-      execSync(`git commit -m "memoir backup ${timestamp}"`, { cwd: gitDir, stdio: 'ignore' });
+      execFileSync('git', ['commit', '-m', `memoir backup ${timestamp}`], { cwd: gitDir, stdio: 'ignore' });
     } catch {
       spinner.succeed(chalk.green('Already up to date! ') + chalk.gray('No changes to push.'));
       return;
     }
 
     spinner.text = `Pushing data to ${chalk.cyan(repoUrl)}...`;
-    execSync(`git push ${repoUrl} main`, { cwd: gitDir, stdio: 'ignore' });
+    execFileSync('git', ['push', repoUrl, 'main'], { cwd: gitDir, stdio: 'ignore' });
 
     spinner.succeed(chalk.green('Sync complete! ') + chalk.gray('(Uploaded securely to GitHub)'));
   } catch (err) {
+    if (err.message.includes('invalid characters')) throw err;
     throw new Error('Failed to push to git repository. Ensure your credentials are configured and the repository exists.');
   } finally {
     await fs.remove(gitDir);

package/src/providers/restore.js

@@ -2,34 +2,33 @@ import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { restoreMemories } from '../adapters/restore.js';
 
 export async function fetchFromLocal(config, stagingDir, spinner) {
   const sourceDir = config.localPath;
   if (!sourceDir) throw new Error('Local path is not configured.');
-  
+
   const resolvedSource = sourceDir.replace(/^~/, os.homedir());
-  
+
   if (!(await fs.pathExists(resolvedSource))) {
     throw new Error(`The backup directory does not exist: ${resolvedSource}`);
   }
 
   spinner.text = `Fetching data from local directory: ${chalk.cyan(resolvedSource)}`;
   await fs.copy(resolvedSource, stagingDir);
-  
+
   return await restoreMemories(stagingDir, spinner);
 }
 
 export async function fetchFromGit(config, stagingDir, spinner) {
   const repoUrl = config.gitRepo;
   if (!repoUrl) throw new Error('Git repository is not configured.');
-  
+
   spinner.text = `Cloning memory from Git remote: ${chalk.cyan(repoUrl)}`;
-  
+
   try {
-    // Clone depth 1 to make it fast
-    execSync(`git clone --depth 1 ${repoUrl} .`, { cwd: stagingDir, stdio: 'ignore' });
+    execFileSync('git', ['clone', '--depth', '1', repoUrl, '.'], { cwd: stagingDir, stdio: 'ignore' });
   } catch (err) {
     throw new Error('Failed to pull from git repository. Ensure your SSH keys are configured and the repository is accessible.');
   }

package/src/tools/aider.js

@@ -0,0 +1,31 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const home = os.homedir();
+const cwd = process.cwd();
+
+export default {
+  key: 'aider',
+  name: 'Aider',
+  icon: '🔧',
+  format: 'Markdown system prompt in .aider.system-prompt.md. Contains instructions that get injected into Aider\'s system prompt. Supports coding style, conventions, and project context.',
+
+  discover() {
+    const files = [];
+    const projectFile = path.join(cwd, '.aider.system-prompt.md');
+    if (fs.existsSync(projectFile)) {
+      files.push({ filePath: projectFile, content: fs.readFileSync(projectFile, 'utf-8'), scope: 'project' });
+    }
+    const homeFile = path.join(home, '.aider.system-prompt.md');
+    const alreadyFound = files.some(f => path.resolve(f.filePath) === path.resolve(homeFile));
+    if (fs.existsSync(homeFile) && !alreadyFound) {
+      files.push({ filePath: homeFile, content: fs.readFileSync(homeFile, 'utf-8'), scope: 'user' });
+    }
+    return files;
+  },
+
+  targetPath() {
+    return path.join(cwd, '.aider.system-prompt.md');
+  }
+};

package/src/tools/claude.js

@@ -0,0 +1,51 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const home = os.homedir();
+const cwd = process.cwd();
+
+export default {
+  key: 'claude',
+  name: 'Claude',
+  icon: '🟣',
+  format: 'Markdown instructions in CLAUDE.md. Supports sections for project context, coding conventions, tool preferences, and workflow rules. Written as direct instructions to Claude.',
+
+  discover() {
+    const files = [];
+
+    const projectFile = path.join(cwd, 'CLAUDE.md');
+    if (fs.existsSync(projectFile)) {
+      files.push({ filePath: projectFile, content: fs.readFileSync(projectFile, 'utf-8'), scope: 'project' });
+    }
+
+    const memoryBase = path.join(home, '.claude', 'projects');
+    if (fs.existsSync(memoryBase)) {
+      const cwdEncoded = cwd.replace(/\//g, '-');
+      const projectDirs = fs.readdirSync(memoryBase).filter(d => {
+        if (!fs.statSync(path.join(memoryBase, d)).isDirectory()) return false;
+        return d === cwdEncoded || cwdEncoded.startsWith(d) || d.startsWith(cwdEncoded);
+      });
+      for (const dir of projectDirs) {
+        const memoryDir = path.join(memoryBase, dir, 'memory');
+        if (fs.existsSync(memoryDir)) {
+          const mdFiles = fs.readdirSync(memoryDir).filter(f => f.endsWith('.md'));
+          for (const f of mdFiles) {
+            const filePath = path.join(memoryDir, f);
+            files.push({ filePath, content: fs.readFileSync(filePath, 'utf-8'), scope: 'user' });
+          }
+        }
+        const claudeMd = path.join(memoryBase, dir, 'CLAUDE.md');
+        if (fs.existsSync(claudeMd)) {
+          files.push({ filePath: claudeMd, content: fs.readFileSync(claudeMd, 'utf-8'), scope: 'user' });
+        }
+      }
+    }
+
+    return files;
+  },
+
+  targetPath() {
+    return path.join(cwd, 'CLAUDE.md');
+  }
+};

package/src/tools/codex.js

@@ -0,0 +1,24 @@
+import fs from 'fs';
+import path from 'path';
+
+const cwd = process.cwd();
+
+export default {
+  key: 'codex',
+  name: 'Codex',
+  icon: '🟢',
+  format: 'Markdown instructions in AGENTS.md. Written as instructions for OpenAI Codex agent. Supports project context, coding conventions, and task guidance.',
+
+  discover() {
+    const files = [];
+    const projectFile = path.join(cwd, 'AGENTS.md');
+    if (fs.existsSync(projectFile)) {
+      files.push({ filePath: projectFile, content: fs.readFileSync(projectFile, 'utf-8'), scope: 'project' });
+    }
+    return files;
+  },
+
+  targetPath() {
+    return path.join(cwd, 'AGENTS.md');
+  }
+};

package/src/tools/copilot.js

@@ -0,0 +1,24 @@
+import fs from 'fs';
+import path from 'path';
+
+const cwd = process.cwd();
+
+export default {
+  key: 'copilot',
+  name: 'GitHub Copilot',
+  icon: '🐙',
+  format: 'Markdown instructions in .github/copilot-instructions.md. Written as instructions for GitHub Copilot. Supports coding style, project context, and language preferences.',
+
+  discover() {
+    const files = [];
+    const projectFile = path.join(cwd, '.github', 'copilot-instructions.md');
+    if (fs.existsSync(projectFile)) {
+      files.push({ filePath: projectFile, content: fs.readFileSync(projectFile, 'utf-8'), scope: 'project' });
+    }
+    return files;
+  },
+
+  targetPath() {
+    return path.join(cwd, '.github', 'copilot-instructions.md');
+  }
+};

package/src/tools/cursor.js

@@ -0,0 +1,24 @@
+import fs from 'fs';
+import path from 'path';
+
+const cwd = process.cwd();
+
+export default {
+  key: 'cursor',
+  name: 'Cursor',
+  icon: '⚡',
+  format: 'Plain text or markdown rules in .cursorrules. Contains coding conventions, style preferences, and project-specific instructions for Cursor AI.',
+
+  discover() {
+    const files = [];
+    const projectFile = path.join(cwd, '.cursorrules');
+    if (fs.existsSync(projectFile)) {
+      files.push({ filePath: projectFile, content: fs.readFileSync(projectFile, 'utf-8'), scope: 'project' });
+    }
+    return files;
+  },
+
+  targetPath() {
+    return path.join(cwd, '.cursorrules');
+  }
+};

package/src/tools/gemini.js

@@ -0,0 +1,31 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const home = os.homedir();
+const cwd = process.cwd();
+
+export default {
+  key: 'gemini',
+  name: 'Gemini',
+  icon: '🔵',
+  format: 'Markdown instructions in GEMINI.md. Written as direct instructions to Gemini. Supports project context, coding style, preferences, and behavioral rules.',
+
+  discover() {
+    const files = [];
+    const projectFile = path.join(cwd, 'GEMINI.md');
+    if (fs.existsSync(projectFile)) {
+      files.push({ filePath: projectFile, content: fs.readFileSync(projectFile, 'utf-8'), scope: 'project' });
+    }
+    const homeFile = path.join(home, 'GEMINI.md');
+    const alreadyFound = files.some(f => path.resolve(f.filePath) === path.resolve(homeFile));
+    if (fs.existsSync(homeFile) && !alreadyFound) {
+      files.push({ filePath: homeFile, content: fs.readFileSync(homeFile, 'utf-8'), scope: 'user' });
+    }
+    return files;
+  },
+
+  targetPath() {
+    return path.join(cwd, 'GEMINI.md');
+  }
+};

package/src/tools/index.js

@@ -0,0 +1,26 @@
+import claude from './claude.js';
+import gemini from './gemini.js';
+import codex from './codex.js';
+import cursor from './cursor.js';
+import copilot from './copilot.js';
+import windsurf from './windsurf.js';
+import aider from './aider.js';
+
+const registry = {};
+for (const tool of [claude, gemini, codex, cursor, copilot, windsurf, aider]) {
+  registry[tool.key] = tool;
+}
+
+export function getProfile(key) {
+  return registry[key] || null;
+}
+
+export function getProfileKeys() {
+  return Object.keys(registry);
+}
+
+export function getProfileChoices() {
+  return Object.values(registry).map(t => ({ name: t.name, value: t.key }));
+}
+
+export { registry as profiles };

package/src/tools/windsurf.js

@@ -0,0 +1,24 @@
+import fs from 'fs';
+import path from 'path';
+
+const cwd = process.cwd();
+
+export default {
+  key: 'windsurf',
+  name: 'Windsurf',
+  icon: '🏄',
+  format: 'Plain text or markdown rules in .windsurfrules. Contains coding conventions, style preferences, and project-specific instructions for Windsurf AI.',
+
+  discover() {
+    const files = [];
+    const projectFile = path.join(cwd, '.windsurfrules');
+    if (fs.existsSync(projectFile)) {
+      files.push({ filePath: projectFile, content: fs.readFileSync(projectFile, 'utf-8'), scope: 'project' });
+    }
+    return files;
+  },
+
+  targetPath() {
+    return path.join(cwd, '.windsurfrules');
+  }
+};