memoir-cli 2.2.0 → 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

@@ -13,6 +13,7 @@ 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);
@@ -57,8 +58,9 @@ if (process.argv.length <= 2) {
     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' +
+    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 --only claude,gemini to sync specific tools') + '\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');
@@ -93,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);
@@ -107,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);
@@ -121,9 +125,10 @@ 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);
@@ -134,9 +139,10 @@ program
   .command('doctor')
   .alias('diagnose')
   .description('Diagnose common issues with your memoir setup')
-  .action(async () => {
+  .option('-p, --profile <name>', 'Use a specific profile')
+  .action(async (options) => {
     try {
-      await doctorCommand();
+      await doctorCommand(options);
     } catch (err) {
       console.error(chalk.red('\n✖ Error:'), err.message);
       process.exit(1);
@@ -147,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);
@@ -160,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);
@@ -175,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);
@@ -189,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);
@@ -220,7 +230,6 @@ program
       console.log('\n' + chalk.cyan(`Updating memoir ${VERSION} → ${chalk.green.bold(latest)}...`) + '\n');
 
       const { execSync } = await import('child_process');
-      // Detect package manager — prefer the one that installed memoir
       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';
@@ -254,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.2.0",
+  "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

@@ -298,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;

package/src/commands/doctor.js

@@ -74,7 +74,7 @@ async function scanForSecrets(files) {
   return warnings;
 }
 
-export async function doctorCommand() {
+export async function doctorCommand(options = {}) {
   const spinner = ora({ text: 'Running diagnostics...', color: 'cyan' }).start();
   const lines = [];
   let passCount = 0;
@@ -87,7 +87,7 @@ export async function doctorCommand() {
 
   // 1. Config check
   spinner.text = 'Checking configuration...';
-  const config = await getConfig();
+  const config = await getConfig(options.profile);
   if (config) {
     const providerLabel = config.provider === 'git' ? 'git' : 'local';
     const dest = config.provider === 'git' ? config.gitRepo : config.localPath;

package/src/commands/profile.js

@@ -0,0 +1,199 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+import inquirer from 'inquirer';
+import { execFileSync } from 'child_process';
+import {
+  getRawConfig, listProfiles, getActiveProfileName,
+  createProfile, switchProfile, deleteProfile
+} from '../config.js';
+
+function getGitHubUsername() {
+  try {
+    return execFileSync('gh', ['api', 'user', '--jq', '.login'], { encoding: 'utf8' }).trim();
+  } catch {
+    try {
+      return execFileSync('git', ['config', '--global', 'user.name'], { encoding: 'utf8' }).trim();
+    } catch { return ''; }
+  }
+}
+
+export async function profileListCommand() {
+  const profiles = await listProfiles();
+  const active = await getActiveProfileName();
+  const raw = await getRawConfig();
+
+  if (profiles.length === 0) {
+    console.log('\n' + chalk.yellow('No profiles configured. Run ') + chalk.cyan('memoir init') + chalk.yellow(' first.\n'));
+    return;
+  }
+
+  console.log();
+  console.log(chalk.bold.white('  Profiles:\n'));
+
+  for (const name of profiles) {
+    const isActive = name === active;
+    const marker = isActive ? chalk.green(' ✔ ') : chalk.gray('   ');
+    const label = isActive ? chalk.white.bold(name) : chalk.white(name);
+
+    // Get profile details
+    let detail = '';
+    if (raw.version >= 2 && raw.profiles?.[name]) {
+      const p = raw.profiles[name];
+      const dest = p.provider === 'git' ? p.gitRepo : p.localPath;
+      detail = chalk.gray(` → ${dest}`);
+      if (p.only) detail += chalk.gray(` (${p.only.join(', ')})`);
+    } else if (!raw.version) {
+      const dest = raw.provider === 'git' ? raw.gitRepo : raw.localPath;
+      detail = chalk.gray(` → ${dest}`);
+    }
+
+    console.log(`${marker}${label}${detail}`);
+  }
+  console.log();
+}
+
+export async function profileCreateCommand(name) {
+  const profiles = await listProfiles();
+  if (profiles.includes(name)) {
+    console.log(chalk.red(`\n✖ Profile "${name}" already exists.\n`));
+    return;
+  }
+
+  console.log('\n' + chalk.cyan(`Creating profile: ${chalk.bold(name)}\n`));
+
+  const detectedUser = getGitHubUsername();
+
+  const { provider } = await inquirer.prompt([{
+    type: 'list',
+    name: 'provider',
+    message: 'Storage for this profile?',
+    choices: [
+      { name: 'GitHub', value: 'git' },
+      { name: 'Local folder', value: 'local' }
+    ]
+  }]);
+
+  const profileConfig = { provider };
+
+  if (provider === 'local') {
+    const { localPath } = await inquirer.prompt([{
+      type: 'input',
+      name: 'localPath',
+      message: 'Save to:',
+      validate: (input) => input.trim() ? true : 'Required'
+    }]);
+    profileConfig.localPath = localPath;
+  } else {
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'username',
+        message: 'GitHub username:',
+        default: detectedUser || undefined,
+        validate: (input) => input.trim() ? true : 'Required'
+      },
+      {
+        type: 'input',
+        name: 'repo',
+        message: 'Repo name:',
+        default: `ai-memory-${name}`,
+        validate: (input) => input.trim() ? true : 'Required'
+      }
+    ]);
+    const username = answers.username.trim();
+    const repo = answers.repo.trim();
+    profileConfig.gitRepo = `https://github.com/${username}/${repo}.git`;
+
+    // Auto-create repo if possible
+    try {
+      execFileSync('gh', ['repo', 'view', `${username}/${repo}`], { stdio: 'ignore' });
+      console.log(chalk.gray(`  ✔ Repo exists`));
+    } catch {
+      try {
+        execFileSync('gh', ['repo', 'create', `${username}/${repo}`, '--private', '--description', `AI memory backup - ${name} (memoir-cli)`], { stdio: 'ignore' });
+        console.log(chalk.green(`  ✔ Created private repo`));
+      } catch {
+        console.log(chalk.yellow(`  ⚠ Could not auto-create repo. Create it manually on GitHub.`));
+      }
+    }
+  }
+
+  // Ask which tools to sync (optional filter)
+  const { filterTools } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'filterTools',
+    message: 'Limit this profile to specific tools?',
+    default: false
+  }]);
+
+  if (filterTools) {
+    const { tools } = await inquirer.prompt([{
+      type: 'checkbox',
+      name: 'tools',
+      message: 'Which tools should this profile sync?',
+      choices: [
+        { name: 'Claude Code', value: 'claude' },
+        { name: 'Gemini CLI', value: 'gemini' },
+        { name: 'OpenAI Codex', value: 'codex' },
+        { name: 'Cursor', value: 'cursor' },
+        { name: 'GitHub Copilot', value: 'copilot' },
+        { name: 'Windsurf', value: 'windsurf' },
+        { name: 'Zed', value: 'zed' },
+        { name: 'Cline', value: 'cline' },
+        { name: 'Continue.dev', value: 'continue' },
+        { name: 'Aider', value: 'aider' }
+      ]
+    }]);
+    if (tools.length > 0) {
+      profileConfig.only = tools;
+    }
+  }
+
+  await createProfile(name, profileConfig);
+
+  // Ask if they want to switch to it
+  const { switchNow } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'switchNow',
+    message: `Switch to "${name}" now?`,
+    default: true
+  }]);
+
+  if (switchNow) {
+    await switchProfile(name);
+  }
+
+  console.log('\n' + boxen(
+    chalk.green(`✔ Profile "${name}" created`) +
+    (switchNow ? chalk.gray(` (now active)`) : ''),
+    { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'green', dimBorder: true }
+  ) + '\n');
+}
+
+export async function profileSwitchCommand(name) {
+  try {
+    await switchProfile(name);
+    console.log('\n' + chalk.green(`✔ Switched to profile "${name}"\n`));
+  } catch (err) {
+    console.log('\n' + chalk.red(`✖ ${err.message}\n`));
+  }
+}
+
+export async function profileDeleteCommand(name) {
+  try {
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: `Delete profile "${name}"? This cannot be undone.`,
+      default: false
+    }]);
+    if (!confirm) {
+      console.log(chalk.gray('\nCancelled.\n'));
+      return;
+    }
+    await deleteProfile(name);
+    console.log('\n' + chalk.green(`✔ Profile "${name}" deleted\n`));
+  } catch (err) {
+    console.log('\n' + chalk.red(`✖ ${err.message}\n`));
+  }
+}

package/src/commands/push.js

@@ -10,7 +10,7 @@ import { extractMemories, adapters } from '../adapters/index.js';
 import { syncToLocal, syncToGit } from '../providers/index.js';
 
 export async function pushCommand(options = {}) {
-  const config = await getConfig();
+  const config = await getConfig(options.profile);
 
   if (!config) {
     console.log('\n' + boxen(
@@ -28,7 +28,9 @@ export async function pushCommand(options = {}) {
   await fs.ensureDir(stagingDir);
 
   try {
-    const onlyFilter = options.only ? options.only.split(',').map(t => t.trim().toLowerCase()) : null;
+    // Profile-level tool filter (config.only) merged with CLI --only flag
+    const onlyRaw = options.only || (config.only ? config.only.join(',') : null);
+    const onlyFilter = onlyRaw ? onlyRaw.split(',').map(t => t.trim().toLowerCase()) : null;
     const foundAny = await extractMemories(stagingDir, spinner, onlyFilter);
 
     if (!foundAny) {

package/src/commands/restore.js

@@ -9,7 +9,7 @@ import { getConfig } from '../config.js';
 import { fetchFromLocal, fetchFromGit } from '../providers/restore.js';
 
 export async function restoreCommand(options = {}) {
-  const config = await getConfig();
+  const config = await getConfig(options.profile);
 
   if (!config) {
     console.log('\n' + boxen(

package/src/commands/resume.js

@@ -92,7 +92,7 @@ async function injectHandoff(content, tool) {
 }
 
 export async function resumeCommand(options = {}) {
-  const config = await getConfig();
+  const config = await getConfig(options.profile);
 
   if (!config) {
     console.log('\n' + boxen(

package/src/commands/snapshot.js

@@ -264,7 +264,7 @@ Keep it under 300 words total. Be specific about file names and features.`;
 }
 
 export async function snapshotCommand(options = {}) {
-  const config = await getConfig();
+  const config = await getConfig(options.profile);
 
   console.log();
   const spinner = ora({ text: chalk.gray('Finding latest session...'), spinner: 'dots' }).start();

package/src/commands/status.js

@@ -6,8 +6,8 @@ import gradient from 'gradient-string';
 import { getConfig } from '../config.js';
 import { adapters } from '../adapters/index.js';
 
-export async function statusCommand() {
-  const config = await getConfig();
+export async function statusCommand(options = {}) {
+  const config = await getConfig(options.profile);
 
   console.log();
 

package/src/commands/view.js

@@ -36,8 +36,8 @@ function isBinaryFile(filePath) {
   return binaryExts.includes(path.extname(filePath).toLowerCase());
 }
 
-export async function viewCommand() {
-  const config = await getConfig();
+export async function viewCommand(options = {}) {
+  const config = await getConfig(options.profile);
   if (!config) {
     console.log(chalk.red('\n✖ Not configured yet. Run: memoir init\n'));
     return;

package/src/config.js

@@ -7,7 +7,8 @@ const CONFIG_DIR = process.platform === 'win32'
   : path.join(os.homedir(), '.config', 'memoir');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 
-export async function getConfig() {
+// Read the raw config file as-is
+export async function getRawConfig() {
   if (await fs.pathExists(CONFIG_FILE)) {
     try {
       return await fs.readJson(CONFIG_FILE);
@@ -18,22 +19,108 @@ export async function getConfig() {
   return null;
 }
 
+// Get resolved config for a specific profile (or active profile)
+// Backwards compatible: v1 flat configs return as-is
+export async function getConfig(profileName = null) {
+  const raw = await getRawConfig();
+  if (!raw) return null;
+
+  // v1 flat config — no profiles, return as-is
+  if (!raw.version || raw.version < 2) return raw;
+
+  // v2 — resolve profile
+  const name = profileName || raw.activeProfile || 'default';
+  const profile = raw.profiles?.[name];
+  if (!profile) return null;
+
+  // Merge top-level shared keys into profile
+  return { ...profile, geminiApiKey: raw.geminiApiKey };
+}
+
+// Save entire raw config
 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);
   }
 }
 
+// Save config for a specific profile (creates v2 format if needed)
+export async function saveProfileConfig(profileName, profileData) {
+  let raw = await getRawConfig() || {};
+  if (!raw.version || raw.version < 2) {
+    raw = migrateConfigToV2(raw);
+  }
+  raw.profiles[profileName] = profileData;
+  await saveConfig(raw);
+}
+
+// Migrate v1 flat config to v2 profiles format
+export function migrateConfigToV2(flat) {
+  const { provider, gitRepo, localPath, geminiApiKey, ...rest } = flat;
+  return {
+    version: 2,
+    activeProfile: 'default',
+    geminiApiKey: geminiApiKey || undefined,
+    profiles: {
+      default: { provider, gitRepo, localPath, ...rest }
+    }
+  };
+}
+
+export async function getActiveProfileName() {
+  const raw = await getRawConfig();
+  if (!raw || !raw.version || raw.version < 2) return 'default';
+  return raw.activeProfile || 'default';
+}
+
+export async function listProfiles() {
+  const raw = await getRawConfig();
+  if (!raw) return [];
+  if (!raw.version || raw.version < 2) return ['default'];
+  return Object.keys(raw.profiles || {});
+}
+
+export async function createProfile(name, profileConfig) {
+  let raw = await getRawConfig() || {};
+  if (!raw.version || raw.version < 2) {
+    raw = migrateConfigToV2(raw);
+  }
+  raw.profiles[name] = profileConfig;
+  await saveConfig(raw);
+}
+
+export async function switchProfile(name) {
+  let raw = await getRawConfig();
+  if (!raw) throw new Error('Not configured. Run memoir init first.');
+  if (!raw.version || raw.version < 2) {
+    raw = migrateConfigToV2(raw);
+  }
+  if (!raw.profiles[name]) throw new Error(`Profile "${name}" does not exist.`);
+  raw.activeProfile = name;
+  await saveConfig(raw);
+}
+
+export async function deleteProfile(name) {
+  const raw = await getRawConfig();
+  if (!raw || !raw.version || raw.version < 2) {
+    throw new Error('No profiles configured.');
+  }
+  if (!raw.profiles[name]) throw new Error(`Profile "${name}" does not exist.`);
+  if (raw.activeProfile === name) throw new Error(`Cannot delete the active profile. Switch first with: memoir profile switch <name>`);
+  if (Object.keys(raw.profiles).length <= 1) throw new Error('Cannot delete the last profile.');
+  delete raw.profiles[name];
+  await saveConfig(raw);
+}
+
 export async function getGeminiApiKey() {
-  const config = await getConfig();
-  return config?.geminiApiKey || process.env.GEMINI_API_KEY || null;
+  const raw = await getRawConfig();
+  return raw?.geminiApiKey || process.env.GEMINI_API_KEY || null;
 }
 
 export async function saveGeminiApiKey(apiKey) {
-  const config = await getConfig() || {};
-  config.geminiApiKey = apiKey;
-  await saveConfig(config);
+  let raw = await getRawConfig() || {};
+  raw.geminiApiKey = apiKey;
+  await saveConfig(raw);
 }

package/src/tools/chatgpt.js

@@ -0,0 +1,24 @@
+import fs from 'fs';
+import path from 'path';
+
+const cwd = process.cwd();
+
+export default {
+  key: 'chatgpt',
+  name: 'ChatGPT',
+  icon: '💬',
+  format: 'Markdown custom instructions in CHATGPT.md. Written as instructions for ChatGPT — your preferences, coding style, response format, and project context. Paste into ChatGPT\'s Custom Instructions or Memory settings.',
+
+  discover() {
+    const files = [];
+    const projectFile = path.join(cwd, 'CHATGPT.md');
+    if (fs.existsSync(projectFile)) {
+      files.push({ filePath: projectFile, content: fs.readFileSync(projectFile, 'utf-8'), scope: 'project' });
+    }
+    return files;
+  },
+
+  targetPath() {
+    return path.join(cwd, 'CHATGPT.md');
+  }
+};

package/src/tools/index.js

@@ -1,5 +1,6 @@
 import claude from './claude.js';
 import gemini from './gemini.js';
+import chatgpt from './chatgpt.js';
 import codex from './codex.js';
 import cursor from './cursor.js';
 import copilot from './copilot.js';
@@ -10,7 +11,7 @@ import continuedev from './continuedev.js';
 import aider from './aider.js';
 
 const registry = {};
-for (const tool of [claude, gemini, codex, cursor, copilot, windsurf, zed, cline, continuedev, aider]) {
+for (const tool of [claude, gemini, chatgpt, codex, cursor, copilot, windsurf, zed, cline, continuedev, aider]) {
   registry[tool.key] = tool;
 }