memoir-cli 2.1.1 → 2.4.0

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
 
-# 🧠 memoir
+# memoir
 **Your AI Remembers Everything. Sync It Everywhere.**
 
 [![npm version](https://img.shields.io/npm/v/memoir-cli.svg?style=flat-square)](https://npmjs.org/package/memoir-cli)
@@ -14,186 +14,164 @@
 
 ---
 
-## 💡 The Problem
+## The Problem
 
-You spend weeks teaching your local AI CLI exactly how you like your code formatted, your preferred architectural patterns, and your project's unique context.
+You spend weeks teaching your AI tools how you code — your preferred patterns, project context, coding standards.
 
-Then, you switch laptops. Or you want to share that setup with your team.
+Then you switch laptops. Or try a new AI tool. Or want your team on the same page.
 
-Suddenly, you're starting from scratch. Your AI's "memory" is trapped in hidden `.gemini` or `.claude` folders on a single machine.
+All that context is trapped in hidden dotfiles on one machine.
 
-## 🚀 The Solution
+## The Solution
 
-`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. Switch from Claude to Gemini in one command.
-
-### Supported Integrations
-- [x] **Gemini CLI**
-- [x] **Claude Code**
-- [x] **OpenAI Codex CLI**
-- [x] **Cursor**
-- [x] **GitHub Copilot**
-- [x] **Windsurf**
-- [x] **Aider**
-
----
-
-## 🛠️ Installation
-
-Install globally via npm so you can use it anywhere on your machine:
+`memoir` extracts, backs up, restores, and **translates** your AI memory across any computer and any tool. One command to save. One command to restore. One command to translate between tools.
 
 ```bash
 npm install -g memoir-cli
 ```
 
-## ⚡ Quick Start
+### Supported Tools (11)
+| Tool | Config synced |
+|------|--------------|
+| **ChatGPT** | `CHATGPT.md` — custom instructions, preferences |
+| **Claude Code** | `~/.claude/` — settings, projects, memory files |
+| **Gemini CLI** | `~/.gemini/` — settings, GEMINI.md |
+| **OpenAI Codex** | `~/.codex/` — config, instructions |
+| **Cursor** | Settings, keybindings, rules |
+| **GitHub Copilot** | Config, settings |
+| **Windsurf** | Settings, keybindings, rules |
+| **Zed** | Settings, keymap, tasks |
+| **Cline** | Settings, rules |
+| **Continue.dev** | Config, rules |
+| **Aider** | `.aider.conf.yml`, system prompt |
+
+Plus **per-project configs**: automatically finds `CLAUDE.md`, `GEMINI.md`, `CHATGPT.md`, `.cursorrules`, `AGENTS.md` across all your projects.
 
-### 1. Initialize
-Run the setup wizard. We'll help you securely link a private GitHub repository or a local sync folder.
+---
 
+## Quick Start
+
+### 1. Initialize
 ```bash
 memoir init
+# Walks you through setup — GitHub repo or local folder
+# Auto-creates a private repo if you have gh CLI
 ```
 
-### 2. Backup Your Memory
-Just had a great session? Save your AI's learned context to the cloud:
-
+### 2. Back up your memory
 ```bash
 memoir push
-# or simply use the alias:
-memoir remember
 ```
 
-### 3. Restore Anywhere
-Got a new machine? Pull your brain down instantly:
-
+### 3. Restore on a new machine
 ```bash
 memoir restore
-# or:
-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:
-
+### 4. Translate between tools
 ```bash
 memoir migrate --from claude --to gemini
-# or run interactively:
-memoir migrate
+# AI-powered translation — not copy-paste, real rewriting
 ```
 
-Your Claude instructions become a proper `GEMINI.md` — not a copy-paste, but a real translation that follows each tool's conventions.
-
 ---
 
-## 📖 All Commands
+## 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 |
+| `memoir init` | Setup wizard — GitHub or local, upload or download |
+| `memoir push` | Back up all AI configs |
+| `memoir restore` | Restore on a new machine (non-destructive) |
+| `memoir status` | Show detected AI tools |
+| `memoir doctor` | Diagnose issues, scan for secrets |
+| `memoir view` | Preview what's in your backup |
+| `memoir diff` | Show changes since last backup |
+| `memoir migrate` | Translate memory between tools via AI |
+| `memoir snapshot` | Capture current coding session |
+| `memoir resume` | Pick up where you left off |
+| `memoir profile` | Manage profiles (personal/work) |
+| `memoir update` | Self-update to latest version |
 
 ---
 
-## 🎯 Common Workflows
+## Profiles
+
+Separate personal and work configs — different repos, different tools.
 
-### New laptop setup
 ```bash
-# Old machine — save everything
-memoir init    # → Upload → GitHub
+memoir profile create work      # set up work profile with its own repo
+memoir profile create personal  # personal side projects
 
-# New machine — restore everything
-memoir init    # → Download → GitHub
-# All your .claude/, .gemini/, .cursorrules configs restored in 30 seconds
-```
+memoir push --profile work      # sync only work configs
+memoir restore --profile personal
 
-### Switch from Claude to Gemini (or any tool)
-```bash
-memoir migrate --from claude --to gemini
+memoir profile list             # see all profiles
+memoir profile switch work      # change default
 ```
-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
-```
+Each profile can filter which tools to sync, so your personal side project memory never mixes with work.
 
-### 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.
+---
+
+## Common Workflows
 
-### Preview before committing
+### New laptop setup
 ```bash
-memoir migrate --from gemini --to claude --dry-run
-# Shows translated output but writes nothing
+# Old machine
+memoir push
+
+# New machine
+memoir init    # → Download → same GitHub repo
+memoir restore # All configs restored in seconds
 ```
 
-### Protect existing files
+### Translate between tools
 ```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
+memoir migrate --from chatgpt --to claude
+# Your ChatGPT custom instructions become a proper CLAUDE.md
 ```
 
-### Daily sync across machines
+### Fan out to every tool
 ```bash
-# End of day
-memoir push
-
-# Next morning, different machine
-memoir pull
+memoir migrate --from chatgpt --to all
+# One source of truth, every tool gets its own format
 ```
 
-### Check what's on this machine
+### Daily sync
 ```bash
-memoir status
-# Shows checkmarks for every detected AI tool and their config locations
+memoir push      # end of day
+memoir restore   # next morning, different machine
 ```
 
 ---
 
-## 🔒 Security First
+## Security
 
-Your AI memory files often sit right next to sensitive API keys and OAuth tokens. **`memoir` is designed to be paranoid.**
+Memoir **only** syncs config files, instructions, and memory markdown. It never touches credentials, API keys, `.env` files, or auth tokens.
 
-Our specialized adapters intelligently filter your directories. We **only** sync configuration files, custom prompts, and markdown memory (`GEMINI.md`, `CLAUDE.md`). We will never touch, copy, or push `.env` files, `.key` files, or credential caches.
+Run `memoir doctor` to see exactly what would be synced and scan for accidental secrets before pushing.
 
 ---
 
-## 🗺️ Roadmap
+## Roadmap
 
-**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
+- **Universal format** — write one `MEMOIR.md`, generate all tool-specific configs
+- **Cloud sync** — no GitHub needed, encrypted backups
+- **Teams** — shared coding standards across your whole team
+- **Templates** — community-shared AI tool configs
 
 ---
 
-## 🤝 Contributing
+## Contributing
 
-We welcome contributions! Whether it's adding an adapter for a new AI CLI, improving the UI, or helping build the Migration Engine.
+Contributions welcome — especially new tool adapters and migration improvements.
 
-1. Fork the Project
-2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
-3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
-4. Push to the Branch (`git push origin feature/AmazingFeature`)
-5. Open a Pull Request
+1. Fork the repo
+2. Create your branch (`git checkout -b feature/my-feature`)
+3. Commit and push
+4. Open a PR
 
-## 📄 License
+## License
 
-Distributed under the MIT License. See `LICENSE` for more information.
+MIT

package/bin/memoir.js

@@ -7,11 +7,13 @@ import { initCommand } from '../src/commands/init.js';
 import { pushCommand } from '../src/commands/push.js';
 import { restoreCommand } from '../src/commands/restore.js';
 import { statusCommand } from '../src/commands/status.js';
+import { doctorCommand } from '../src/commands/doctor.js';
 import { viewCommand } from '../src/commands/view.js';
 import { diffCommand } from '../src/commands/diff.js';
 import { migrateCommand } from '../src/commands/migrate.js';
 import { snapshotCommand } from '../src/commands/snapshot.js';
 import { resumeCommand } from '../src/commands/resume.js';
+import { profileListCommand, profileCreateCommand, profileSwitchCommand, profileDeleteCommand } from '../src/commands/profile.js';
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
@@ -26,11 +28,17 @@ async function checkForUpdate() {
     clearTimeout(timeout);
     const data = await res.json();
     const latest = data.version;
-    if (latest && latest !== VERSION) {
+    // Only notify if remote is actually newer (not just different)
+    const isNewer = (a, b) => {
+      const [a1, a2, a3] = a.split('.').map(Number);
+      const [b1, b2, b3] = b.split('.').map(Number);
+      return a1 > b1 || (a1 === b1 && a2 > b2) || (a1 === b1 && a2 === b2 && a3 > b3);
+    };
+    if (latest && isNewer(latest, VERSION)) {
       console.log(
         '\n' + boxen(
           chalk.yellow(`Update available: ${VERSION} → ${chalk.green.bold(latest)}`) + '\n' +
-          chalk.gray('Run: ') + chalk.cyan('npm install -g memoir-cli'),
+          chalk.gray('Run: ') + chalk.cyan('memoir update'),
           { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'yellow', dimBorder: true }
         )
       );
@@ -49,8 +57,10 @@ if (process.argv.length <= 2) {
     chalk.cyan('  memoir restore   ') + chalk.gray('— restore on a new machine') + '\n' +
     chalk.cyan('  memoir snapshot  ') + chalk.gray('— capture your current session') + '\n' +
     chalk.cyan('  memoir resume    ') + chalk.gray('— pick up where you left off') + '\n' +
-    chalk.cyan('  memoir status    ') + chalk.gray('— see detected AI tools') + '\n\n' +
-    chalk.gray('  Tip: use --only claude,gemini to sync specific tools') + '\n\n' +
+    chalk.cyan('  memoir status    ') + chalk.gray('— see detected AI tools') + '\n' +
+    chalk.cyan('  memoir profile   ') + chalk.gray('— manage profiles (personal/work)') + '\n' +
+    chalk.cyan('  memoir update    ') + chalk.gray('— update to latest version') + '\n\n' +
+    chalk.gray('  Tip: use --profile work to sync a specific profile') + '\n\n' +
     chalk.gray(`v${VERSION}`),
     { padding: 1, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
   ) + '\n');
@@ -85,7 +95,8 @@ program
   .command('push')
   .alias('remember')
   .description('Back up your AI memory to the cloud')
-  .option('--only <tools>', 'Only sync specific tools (comma-separated: claude,gemini,codex,cursor,copilot,windsurf,aider)')
+  .option('--only <tools>', 'Only sync specific tools (comma-separated)')
+  .option('-p, --profile <name>', 'Use a specific profile')
   .action(async (options) => {
     try {
       await pushCommand(options);
@@ -99,8 +110,9 @@ program
   .command('restore')
   .alias('pull')
   .description('Restore your AI memory on this machine')
-  .option('--only <tools>', 'Only restore specific tools (comma-separated: claude,gemini,codex,cursor,copilot,windsurf,aider)')
+  .option('--only <tools>', 'Only restore specific tools (comma-separated)')
   .option('-y, --yes', 'Skip confirmation prompts (restore all)')
+  .option('-p, --profile <name>', 'Use a specific profile')
   .action(async (options) => {
     try {
       await restoreCommand(options);
@@ -113,9 +125,24 @@ program
 program
   .command('status')
   .description('See what AI tools are on this machine')
-  .action(async () => {
+  .option('-p, --profile <name>', 'Use a specific profile')
+  .action(async (options) => {
     try {
-      await statusCommand();
+      await statusCommand(options);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('doctor')
+  .alias('diagnose')
+  .description('Diagnose common issues with your memoir setup')
+  .option('-p, --profile <name>', 'Use a specific profile')
+  .action(async (options) => {
+    try {
+      await doctorCommand(options);
     } catch (err) {
       console.error(chalk.red('\n✖ Error:'), err.message);
       process.exit(1);
@@ -126,9 +153,10 @@ program
   .command('view')
   .alias('ls')
   .description('Preview what files are in your backup')
-  .action(async () => {
+  .option('-p, --profile <name>', 'Use a specific profile')
+  .action(async (options) => {
     try {
-      await viewCommand();
+      await viewCommand(options);
     } catch (err) {
       console.error(chalk.red('\n✖ Error:'), err.message);
       process.exit(1);
@@ -139,9 +167,10 @@ program
   .command('diff')
   .alias('changes')
   .description('Show what changed since your last backup')
-  .action(async () => {
+  .option('-p, --profile <name>', 'Use a specific profile')
+  .action(async (options) => {
     try {
-      await diffCommand();
+      await diffCommand(options);
     } catch (err) {
       console.error(chalk.red('\n✖ Error:'), err.message);
       process.exit(1);
@@ -154,6 +183,7 @@ program
   .description('Capture your current coding session for handoff')
   .option('--smart', 'Use AI to generate a better summary (requires Gemini API key)')
   .option('--goal <goal>', 'What you want to do next (goal-directed handoff)')
+  .option('-p, --profile <name>', 'Use a specific profile')
   .action(async (options) => {
     try {
       await snapshotCommand(options);
@@ -168,6 +198,7 @@ program
   .description('Pick up where you left off on another machine')
   .option('--inject', 'Write the handoff where your AI tool will read it')
   .option('--to <tool>', 'Target tool for injection (claude, gemini, cursor, codex)')
+  .option('-p, --profile <name>', 'Use a specific profile')
   .action(async (options) => {
     try {
       await resumeCommand(options);
@@ -177,6 +208,46 @@ program
     }
   });
 
+program
+  .command('update')
+  .alias('upgrade')
+  .description('Update memoir to the latest version')
+  .action(async () => {
+    try {
+      const res = await fetch('https://registry.npmjs.org/memoir-cli/latest');
+      const data = await res.json();
+      const latest = data.version;
+
+      if (latest === VERSION) {
+        console.log('\n' + boxen(
+          chalk.green('✔ Already up to date!') + '\n' +
+          chalk.gray(`v${VERSION}`),
+          { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'green', dimBorder: true }
+        ) + '\n');
+        return;
+      }
+
+      console.log('\n' + chalk.cyan(`Updating memoir ${VERSION} → ${chalk.green.bold(latest)}...`) + '\n');
+
+      const { execSync } = await import('child_process');
+      const execPath = process.argv[1] || '';
+      const useBun = execPath.includes('.bun') || process.env.BUN_INSTALL;
+      const cmd = useBun ? 'bun install -g memoir-cli' : 'npm install -g memoir-cli';
+
+      execSync(cmd, { stdio: 'inherit' });
+
+      console.log('\n' + boxen(
+        gradient.pastel('  Updated!  ') + '\n\n' +
+        chalk.white(`memoir ${VERSION} → ${chalk.green.bold(latest)}`),
+        { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
+      ) + '\n');
+    } catch (err) {
+      console.error(chalk.red('\n✖ Update failed:'), err.message);
+      console.log(chalk.gray('Try manually: ') + chalk.cyan('npm install -g memoir-cli'));
+      process.exit(1);
+    }
+  });
+
 program
   .command('migrate')
   .description('Translate memory between AI tools (Claude, Gemini, Codex, Cursor, etc.)')
@@ -192,6 +263,60 @@ program
     }
   });
 
+// Profile management
+const profile = program.command('profile').description('Manage profiles (personal, work, etc.)');
+
+profile
+  .command('list')
+  .alias('ls')
+  .description('List all profiles')
+  .action(async () => {
+    try {
+      await profileListCommand();
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
+profile
+  .command('create <name>')
+  .description('Create a new profile')
+  .action(async (name) => {
+    try {
+      await profileCreateCommand(name);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
+profile
+  .command('switch <name>')
+  .alias('use')
+  .description('Switch to a profile')
+  .action(async (name) => {
+    try {
+      await profileSwitchCommand(name);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
+profile
+  .command('delete <name>')
+  .alias('rm')
+  .description('Delete a profile')
+  .action(async (name) => {
+    try {
+      await profileDeleteCommand(name);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
 program.hook('postAction', async () => {
   await checkForUpdate();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memoir-cli",
-  "version": "2.1.1",
+  "version": "2.4.0",
   "description": "Sync AI memory across devices. Back up and restore Claude, Gemini, Codex, Cursor, Copilot, Windsurf configs. Snapshot coding sessions and resume on another machine. Migrate instructions between AI assistants.",
   "main": "src/index.js",
   "type": "module",
@@ -35,6 +35,10 @@
     "copilot",
     "windsurf",
     "aider",
+    "zed",
+    "cline",
+    "continue-dev",
+    "profiles",
     "ai-memory",
     "ai-tools",
     "dotfiles",
@@ -42,6 +46,7 @@
     "claude-code",
     "gemini-cli",
     "openai",
+    "chatgpt",
     "ai-assistant",
     "coding-assistant",
     "context-sync",
@@ -58,7 +63,6 @@
     "fs-extra": "^11.2.0",
     "gradient-string": "^3.0.0",
     "inquirer": "^9.2.15",
-    "open": "^11.0.0",
-    "ora": "^7.0.1"
+"ora": "^7.0.1"
   }
 }

package/src/adapters/index.js

@@ -127,6 +127,80 @@ export const adapters = [
       return false;
     }
   },
+  {
+    name: 'Zed',
+    icon: '🔶',
+    source: isWin
+      ? path.join(appData, 'Zed')
+      : path.join(home, '.config', 'zed'),
+    filter: (src) => {
+      const zedDir = isWin
+        ? path.join(appData, 'Zed')
+        : path.join(home, '.config', 'zed');
+      const rel = path.relative(zedDir, src);
+      if (src === zedDir) return true;
+      const basename = path.basename(src);
+      // Skip known heavy/non-config directories
+      const skipDirs = ['extensions', 'themes', 'logs', 'db', 'copilot', 'node', 'languages'];
+      const topDir = rel.split(path.sep)[0];
+      if (skipDirs.includes(topDir)) return false;
+      // Only sync specific config files in root
+      const allowed = ['settings.json', 'keymap.json', 'tasks.json'];
+      if (allowed.includes(basename) && !rel.includes(path.sep)) return true;
+      // Allow .md files in root
+      if (basename.endsWith('.md') && !rel.includes(path.sep)) return true;
+      return false;
+    }
+  },
+  {
+    name: 'Cline',
+    icon: '🤖',
+    source: isWin
+      ? path.join(appData, 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev')
+      : path.join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev'),
+    filter: (src) => {
+      const clineDir = isWin
+        ? path.join(appData, 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev')
+        : path.join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev');
+      const rel = path.relative(clineDir, src);
+      if (src === clineDir) return true;
+      const basename = path.basename(src);
+      const topDir = rel.split(path.sep)[0];
+      // Skip known heavy/non-config directories
+      const skipDirs = ['tasks', 'checkpoints', '.cache', 'images'];
+      if (skipDirs.includes(topDir)) return false;
+      // Allow settings/ and rules/ directories
+      if (topDir === 'settings' || topDir === 'rules') return true;
+      // Allow .md files in root
+      if (basename.endsWith('.md') && !rel.includes(path.sep)) return true;
+      return false;
+    }
+  },
+  {
+    name: 'Continue.dev',
+    icon: '🔄',
+    source: isWin
+      ? path.join(process.env.USERPROFILE || home, '.continue')
+      : path.join(home, '.continue'),
+    filter: (src) => {
+      const continueDir = isWin
+        ? path.join(process.env.USERPROFILE || home, '.continue')
+        : path.join(home, '.continue');
+      const rel = path.relative(continueDir, src);
+      if (src === continueDir) return true;
+      const basename = path.basename(src);
+      // Skip known heavy/non-config directories
+      const skipDirs = ['sessions', 'dev_data', 'logs', 'index', 'cache', 'types'];
+      const topDir = rel.split(path.sep)[0];
+      if (skipDirs.includes(topDir)) return false;
+      // Only sync specific config files in root
+      const allowed = ['config.json', 'config.ts', 'config.yaml', '.continuerules'];
+      if (allowed.includes(basename) && !rel.includes(path.sep)) return true;
+      // Allow .md files in root
+      if (basename.endsWith('.md') && !rel.includes(path.sep)) return true;
+      return false;
+    }
+  },
   {
     name: 'Aider',
     icon: '🔧',
@@ -224,7 +298,7 @@ export async function extractMemories(stagingDir, spinner, onlyFilter = null) {
     spinner.text = `📁 Scanning for project-level AI configs...`;
 
     const projectFiles = [
-      'CLAUDE.md', 'GEMINI.md', 'AGENTS.md', '.cursorrules',
+      'CLAUDE.md', 'GEMINI.md', 'CHATGPT.md', 'AGENTS.md', '.cursorrules',
       '.github/copilot-instructions.md', '.windsurfrules',
       '.aider.conf.yml', '.clinerules'
     ];

package/src/commands/diff.js

@@ -50,8 +50,8 @@ function simpleDiff(oldText, newText) {
   return output;
 }
 
-export async function diffCommand() {
-  const config = await getConfig();
+export async function diffCommand(options = {}) {
+  const config = await getConfig(options.profile);
   if (!config) {
     console.log(chalk.red('\n✖ Not configured yet. Run: memoir init\n'));
     return;