memoir-cli 2.2.0 → 2.5.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,10 @@ 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 { loginCommand, logoutCommand } from '../src/commands/login.js';
+import { cloudPushCommand, cloudRestoreCommand } from '../src/commands/cloud.js';
+import { historyCommand } from '../src/commands/history.js';
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
@@ -57,8 +61,14 @@ 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.white.bold('Cloud (Pro):') + '\n' +
+    chalk.cyan('  memoir login         ') + chalk.gray('— sign in to memoir cloud') + '\n' +
+    chalk.cyan('  memoir cloud push    ') + chalk.gray('— back up to the cloud') + '\n' +
+    chalk.cyan('  memoir cloud restore ') + chalk.gray('— restore from cloud') + '\n' +
+    chalk.cyan('  memoir history       ') + chalk.gray('— view backup versions') + '\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 +103,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 +118,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 +133,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 +147,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 +161,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 +175,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 +191,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 +206,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 +238,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 +271,128 @@ program
     }
   });
 
+// Cloud auth
+program
+  .command('login')
+  .description('Sign in to memoir cloud')
+  .action(async () => {
+    try {
+      await loginCommand();
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('logout')
+  .description('Sign out of memoir cloud')
+  .action(async () => {
+    try {
+      await logoutCommand();
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
+// Cloud sync
+const cloud = program.command('cloud').description('Cloud backup and restore (Pro)');
+
+cloud
+  .command('push')
+  .description('Back up your AI memory to the cloud')
+  .option('--only <tools>', 'Only sync specific tools (comma-separated)')
+  .action(async (options) => {
+    try {
+      await cloudPushCommand(options);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
+cloud
+  .command('restore')
+  .description('Restore your AI memory from the cloud')
+  .option('--only <tools>', 'Only restore specific tools (comma-separated)')
+  .option('-y, --yes', 'Skip confirmation prompts')
+  .option('--version <number>', 'Restore a specific version')
+  .action(async (options) => {
+    try {
+      await cloudRestoreCommand(options);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('history')
+  .description('View your cloud backup history')
+  .action(async () => {
+    try {
+      await historyCommand();
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
+// 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.5.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'
     ];