memoir-cli 3.1.1 → 3.2.1

package/POSTS-READY-TO-GO.md

@@ -0,0 +1,215 @@
+# Ready-to-Post Social Media — Copy & Paste Now
+
+Post these THIS WEEK. Don't wait for perfection.
+
+---
+
+## 1. Reddit r/programming — POST TODAY
+
+**URL:** https://www.reddit.com/r/programming/submit
+
+**Title:** I built a CLI that syncs your AI coding memory across 11 tools and every device
+
+**Body:**
+
+Every AI coding tool stores your preferences in its own hidden config files. Claude has `~/.claude/` and `CLAUDE.md`. Cursor has `.cursorrules`. Gemini has `GEMINI.md`. None of them talk to each other, and none of them sync between machines.
+
+I got tired of re-teaching my AI tools every time I switched from my Mac to my PC, so I built **memoir** — a CLI that backs up, restores, and translates your AI memory across devices and tools.
+
+**What it does:**
+
+- `memoir push` — backs up AI configs, project knowledge, and your current coding session
+- `memoir restore` — restores everything on any machine (Mac, Windows, Linux)
+- `memoir migrate --from claude --to cursor` — AI-powered translation between tools (rewrites conventions, doesn't just copy files)
+- `memoir mcp` — MCP server so your editor can search/save memories in-conversation
+
+**What makes it interesting:**
+
+It doesn't just sync config files. It captures *session state* — what files you changed, what decisions you made, what you were debugging — and injects that context when you restore. Your AI literally picks up where you left off.
+
+It also syncs your actual workspace: git repos are auto-cloned, non-git projects are bundled and unpacked, uncommitted changes are saved as patches.
+
+E2E encrypted (AES-256-GCM), secret scanning built in, MIT licensed.
+
+```
+npm install -g memoir-cli
+```
+
+GitHub: https://github.com/camgitt/memoir
+Website: https://memoir.sh
+
+Would love to hear what workflows people would find useful. Currently thinking about shareable context links for team onboarding.
+
+---
+
+## 2. Reddit r/cursor — POST TOMORROW
+
+**URL:** https://www.reddit.com/r/cursor/submit
+
+**Title:** Sync your .cursorrules and AI context across machines (and 10 other AI tools)
+
+**Body:**
+
+Quick question for multi-machine Cursor users — how are you keeping your `.cursorrules` and settings in sync across devices?
+
+I built **memoir** because I kept losing my AI context switching between machines. It's a CLI that syncs Cursor configs alongside 10 other AI tools — Claude Code, Gemini CLI, ChatGPT, Codex, Copilot, Windsurf, Zed, Cline, Continue.dev, and Aider. 11 tools total.
+
+The part that's been most useful for me:
+
+```
+memoir migrate --from claude --to cursor
+```
+
+This uses AI to actually *translate* your Claude CLAUDE.md into a proper `.cursorrules` that follows Cursor's conventions. Not a file copy — a real rewrite.
+
+It also captures your current coding session and lets you resume on another machine. Your AI picks up mid-conversation.
+
+```
+npm install -g memoir-cli
+memoir init
+memoir push     # backs up .cursorrules + settings + projects
+memoir restore  # restores everything on another machine
+```
+
+E2E encrypted, MIT licensed, free tier available.
+
+GitHub: https://github.com/camgitt/memoir
+
+What other Cursor-specific workflows would be useful? Happy to add things.
+
+---
+
+## 3. Reddit r/ClaudeAI — POST DAY AFTER
+
+**URL:** https://www.reddit.com/r/ClaudeAI/submit
+
+**Title:** Built a CLI to sync your CLAUDE.md and Claude Code memory across machines
+
+**Body:**
+
+For those of you using Claude Code on multiple machines — how are you keeping your CLAUDE.md files and ~/.claude/ settings in sync?
+
+I built **memoir** to solve this. It's a CLI that backs up and restores your Claude Code memory (plus 10 other AI tools) across any machine.
+
+```
+memoir push      # backs up ~/.claude/, CLAUDE.md files, session state, projects
+memoir restore   # restores everything on another machine
+```
+
+The part I find most useful: **session handoff**. memoir captures what you were working on — files changed, errors hit, decisions made — and injects that context when you restore. Claude literally picks up where you left off on a different machine.
+
+It also does AI-powered translation if you use multiple tools:
+
+```
+memoir migrate --from claude --to cursor
+# Rewrites your CLAUDE.md into proper .cursorrules
+```
+
+And it ships an MCP server (`memoir mcp`) with 6 tools your editor can use to search and save memories in-conversation.
+
+E2E encrypted, secret scanning built in, MIT licensed, ~100kb installed.
+
+```
+npm install -g memoir-cli
+```
+
+GitHub: https://github.com/camgitt/memoir
+Website: https://memoir.sh
+
+Would love feedback from the Claude community. What would make this more useful for your workflow?
+
+---
+
+## 4. X/Twitter Thread — POST SAME DAY AS REDDIT
+
+Copy each tweet as a separate post in a thread:
+
+**Tweet 1:**
+AI tools forget you every time you switch machines.
+
+I built memoir — a CLI that syncs your AI memory across 11 tools and every device.
+
+One command to save. One command to restore. Your AI picks up mid-conversation.
+
+Here's what it does:
+
+**Tweet 2:**
+The problem: Claude has CLAUDE.md. Cursor has .cursorrules. Gemini has GEMINI.md.
+
+None of them sync. None of them talk to each other.
+
+Switch machines? Start from zero. Switch tools? Re-teach everything.
+
+memoir fixes this.
+
+**Tweet 3:**
+memoir push      # save everything
+memoir restore   # restore anywhere
+
+It syncs three layers:
+- AI memory (configs across 11 tools)
+- Session state (what you were doing)
+- Workspace (your actual projects)
+
+**Tweet 4:**
+The killer feature: AI-powered translation between tools.
+
+memoir migrate --from claude --to cursor
+
+This doesn't just copy files. It rewrites your Claude instructions into proper .cursorrules following Cursor's conventions.
+
+Works between all 11 tools.
+
+**Tweet 5:**
+Session handoff is the other thing nothing else does.
+
+memoir captures what files you changed, what decisions you made, what you were debugging.
+
+On restore, it injects that context. Your AI literally picks up where you left off.
+
+**Tweet 6:**
+npm install -g memoir-cli
+
+Free & open source. MIT licensed. ~100kb.
+
+Cloud sync available. MCP server included so your editor can search memories in-conversation.
+
+GitHub: github.com/camgitt/memoir
+Website: memoir.sh
+
+Try it and let me know what you think
+
+---
+
+## 5. Cold DM Template (for devs tweeting about AI context loss)
+
+**Search Twitter for:** "lost my cursorrules" OR "claude forgot" OR "new machine setup" OR "re-teaching AI" OR "CLAUDE.md sync"
+
+**DM template:**
+
+Hey! Saw your tweet about [specific pain point]. I built an open-source CLI called memoir that solves exactly this — it syncs your AI memory (CLAUDE.md, .cursorrules, etc.) across machines and tools.
+
+One command to back up, one to restore. Your AI picks up mid-conversation.
+
+github.com/camgitt/memoir
+
+Would love your feedback if you try it!
+
+---
+
+## Posting Schedule
+
+| Day | Platform | Post |
+|-----|----------|------|
+| Today (Thu) | r/programming | Post #1 |
+| Today (Thu) | X/Twitter | Thread (Post #4) |
+| Friday | r/cursor | Post #2 |
+| Friday | r/ClaudeAI | Post #3 |
+| Sat-Sun | X/Twitter | Cold DMs to 10-20 devs |
+
+## Rules
+1. Reply to EVERY comment within 2 hours
+2. Don't be defensive about "it's just dotfiles" — explain session handoff
+3. Ask questions back: "What tools are you using?"
+4. Link the demo SVG/GIF in early replies
+5. Ask 2-3 friends to upvote within first 30 min

package/README.md

@@ -2,52 +2,95 @@
 
 # memoir
 
-**Your AI remembers everything. On every machine.**
+**Persistent memory for AI coding tools.**
 
 [![npm version](https://img.shields.io/npm/v/memoir-cli.svg?style=flat-square&color=7c6ef0)](https://npmjs.org/package/memoir-cli)
 [![npm downloads](https://img.shields.io/npm/dm/memoir-cli.svg?style=flat-square&color=7c6ef0)](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)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen?style=flat-square)](https://nodejs.org)
 
-Close your laptop. Open another one. **Your AI picks up exactly where you left off.**
+Your AI forgets everything between sessions. memoir gives it long-term memory via MCP.
+
+Works with Claude Code, Cursor, Windsurf, Gemini, and 7 more tools.
 
 [Website](https://memoir.sh) • [npm](https://npmjs.org/package/memoir-cli) • [Blog](https://memoir.sh/blog)
 
 <br />
 
+<img src="demo.svg" alt="memoir demo — push, restore, and sync AI memory" width="700" />
+
 </div>
 
 ## The Problem
 
-You spend weeks teaching Claude how you code. Your projects are dialed in. Your AI knows your stack, your decisions, your preferences.
+You told Claude your project uses Zustand, not Redux. You explained your auth middleware to Cursor. You spent weeks building up context across your AI tools.
 
-Then you switch machines. **Everything is gone.** Your AI has amnesia. Your projects aren't there. You start from zero.
+Next session? **Gone.** New machine? **Gone.** Switch tools? **Gone.**
 
-## The Fix
+## How memoir fixes it
 
-```bash
-# On your main machine
-memoir push
+memoir is a **persistent memory layer** that runs via [MCP](https://modelcontextprotocol.io) inside your AI tools. Your AI can search, read, and save memories automatically — across sessions, tools, and machines.
 
-# On any other machine
+```
+you: how does auth work in this project?
+
+  memoir_recall("auth setup architecture")
+  Found 3 memories matching "auth"
+
+claude: Based on your previous sessions: this project uses JWT auth
+  with refresh tokens, the middleware is in src/middleware/auth.ts,
+  and you chose Zustand over Redux for auth state (decided March 12).
+```
+
+No re-explaining. memoir remembered.
+
+## Quick Start
+
+```bash
+# Install
 npm install -g memoir-cli
-memoir restore -y
 
-# Done. Everything's back:
-# ✔ AI memory restored (Claude, Gemini, Cursor, 11 tools)
-# ✔ 44 projects cloned & unpacked
-# ✔ Uncommitted changes applied
-# ✔ Session context injected — AI picks up mid-conversation
+# Setup
+memoir init
 ```
 
-One command to save. One command to restore. That's it.
+### Add MCP to your AI tools
+
+**Claude Code** — add to `~/.mcp.json`:
+```json
+{
+  "mcpServers": {
+    "memoir": { "command": "memoir-mcp" }
+  }
+}
+```
+
+**Cursor** — add to `.cursor/mcp.json`:
+```json
+{
+  "mcpServers": {
+    "memoir": { "command": "memoir-mcp" }
+  }
+}
+```
+
+That's it. Your AI tools now have 6 memory abilities:
+
+| MCP Tool | What it does |
+|----------|-------------|
+| `memoir_recall` | Search across all your AI memories |
+| `memoir_remember` | Save context for future sessions |
+| `memoir_list` | Browse all memory files by tool |
+| `memoir_read` | Read a specific memory in full |
+| `memoir_status` | See which AI tools are detected |
+| `memoir_profiles` | Switch between work/personal |
 
 ## What Gets Synced
 
 memoir syncs three layers that no other tool connects:
 
-### Layer 1: AI Memory
-Your AI tool configs, preferences, and project knowledge across 11 tools.
+### Layer 1: AI Memory (via MCP + CLI)
+Configs, instructions, and project knowledge across 11 tools — searchable and writable from inside any AI conversation.
 
 | Tool | What gets synced |
 |------|-----------------|
@@ -71,7 +114,7 @@ What you were **doing** — not just what your AI knows, but the active context.
 - Injected into your AI on restore so it picks up mid-conversation
 - Secrets auto-redacted (API keys, tokens, passwords stripped before sync)
 
-### Layer 3: Workspace (NEW in v3.1)
+### Layer 3: Workspace
 Your actual projects — code, files, everything.
 
 - **Git projects:** Remote URLs saved, auto-cloned on restore
@@ -79,47 +122,10 @@ Your actual projects — code, files, everything.
 - **Uncommitted work:** Saved as patches, applied after clone
 - **Zero git commands needed** — memoir handles it all
 
-```
-memoir push on Mac:
-  ✔ AI memory backed up
-  ✔ Session context captured
-  ✔ Workspace: 44 projects (17 git, 23 bundled)
-  🔒 E2E encrypted
-
-memoir restore on Windows:
-  ✔ AI memory restored
-  ✔ stock-market-book → C:\Users\You\stock-market-book (cloned)
-  ✔ socialslink → C:\Users\You\socialslink (cloned)
-  ✔ btc-trader → C:\Users\You\btc-trader (unpacked)
-  ✔ 41 more projects restored
-  📋 Session context injected — Claude picks up where you left off
-```
-
-## Quick Start
-
-```bash
-# Install
-npm install -g memoir-cli
-
-# First-time setup
-memoir init
-
-# Back up everything
-memoir push
-
-# Restore on any machine
-memoir restore
-```
-
 ## Key Features
 
-### Workspace sync
-```bash
-memoir push     # scans all projects, saves git URLs + bundles non-git projects
-memoir restore  # auto-clones repos, unpacks bundles, applies uncommitted patches
-```
-
-No manual git commands. memoir detects your projects, tracks their remotes, and restores them anywhere.
+### Cross-tool memory
+Tell Claude something once. Cursor knows it too. memoir is the shared memory layer between all your AI tools.
 
 ### Translate between AI tools
 ```bash
@@ -130,13 +136,17 @@ memoir migrate --from chatgpt --to all
 # Translate to every tool at once
 ```
 
-### Session handoff
+### Cross-machine sync
 ```bash
-# Capture your session (automatic on push, or manual)
-memoir snapshot
+# On your main machine
+memoir push
 
-# Pick up on another machine
-memoir resume --inject --to claude
+# On any other machine
+memoir restore -y
+# ✔ AI memory restored (Claude, Gemini, Cursor, 11 tools)
+# ✔ 44 projects cloned & unpacked
+# ✔ Uncommitted changes applied
+# ✔ Session context injected — AI picks up mid-conversation
 ```
 
 ### E2E Encryption
@@ -145,7 +155,7 @@ memoir encrypt    # toggle encryption on/off
 memoir push       # prompted for passphrase, AES-256-GCM encrypted
 ```
 
-Your backup is encrypted before it leaves your machine. Even if your storage is compromised, your data is safe. Secret scanning auto-redacts API keys, tokens, and passwords.
+Your backup is encrypted before it leaves your machine. Secret scanning auto-redacts API keys, tokens, and passwords.
 
 ### Profiles (personal / work)
 ```bash
@@ -154,26 +164,15 @@ memoir push --profile work
 memoir profile switch personal
 ```
 
-Each profile has its own repo and tool filters. Work configs never mix with personal.
-
-### Cloud sync (Pro)
+### Cloud sync
 ```bash
 memoir login
 memoir cloud push      # encrypted cloud backup
 memoir cloud restore   # restore from any version
-memoir history         # view all backup versions
 ```
 
 ### Cross-platform (Mac / Windows / Linux)
-```bash
-# Push from Mac
-memoir push
-
-# Restore on Windows — paths remap automatically
-memoir restore
-```
-
-Claude's memory paths are automatically remapped between platforms. Projects are cloned to the right locations. It just works.
+Paths remap automatically between platforms. Push from Mac, restore on Windows. It just works.
 
 ## All Commands
 
@@ -182,6 +181,7 @@ Claude's memory paths are automatically remapped between platforms. Projects are
 | `memoir init` | Setup wizard — GitHub or local storage |
 | `memoir push` | Back up AI memory + workspace + session |
 | `memoir restore` | Restore everything on a new machine |
+| `memoir mcp` | Start MCP server for editor integration |
 | `memoir status` | Show detected AI tools |
 | `memoir doctor` | Diagnose issues, scan for secrets |
 | `memoir view` | Preview what's in your backup |
@@ -195,39 +195,44 @@ Claude's memory paths are automatically remapped between platforms. Projects are
 | `memoir cloud restore` | Restore from memoir cloud |
 | `memoir history` | View cloud backup versions |
 | `memoir login` | Sign in to memoir cloud |
+| `memoir share` | Create encrypted shareable link |
+| `memoir upgrade` | View plans and upgrade |
 | `memoir update` | Self-update to latest version |
 
 ## How memoir compares
 
 | Feature | memoir | dotfiles managers | ai-rulez | memories.sh |
 |---------|--------|-------------------|----------|-------------|
+| MCP memory layer | **6 tools** | No | No | No |
 | AI memory sync | **11 tools** | No | 18 tools | 3 tools |
+| Cross-tool recall | **Yes** | No | No | No |
 | Workspace sync | **Yes** | No | No | No |
 | Session handoff | **Yes** | No | No | No |
-| AI-powered translation | **Yes** | No | No | No |
+| AI-powered migration | **Yes** | No | No | No |
 | E2E encryption | **Yes** | No | No | No |
 | Secret scanning | **Yes** | Some | No | No |
 | Cross-platform remap | **Yes** | Some | No | No |
-| Uncommitted work patches | **Yes** | No | No | No |
 | Cloud backup | **Yes** | No | No | Yes ($15/mo) |
 | Profiles | **Yes** | No | No | No |
 | Free & open source | **Yes** | Yes | Yes | No |
 
 ## Common Workflows
 
-### New machine setup
-```bash
-# Old machine
-memoir push
+### Your AI remembers across sessions
+```
+# Monday — you explain your auth setup to Claude
+# ...Claude calls memoir_remember to save the decision
 
-# New machine — one command, everything's back
-npm install -g memoir-cli && memoir init && memoir restore -y
+# Thursday — new conversation
+you: "add a protected route"
+# Claude calls memoir_recall, finds your auth architecture
+# No re-explaining needed
 ```
 
-### Daily sync between machines
+### New machine setup
 ```bash
-memoir push      # end of day on laptop
-memoir restore   # next morning on desktop — AI knows what you were doing
+npm install -g memoir-cli && memoir init && memoir restore -y
+# Done. Everything's back.
 ```
 
 ### Switching AI tools
@@ -253,6 +258,7 @@ memoir restore --profile team
 - **Auto-redaction** — secrets stripped from session handoffs before sync
 - **No credentials synced** — .env files, auth tokens, and API keys are never included
 - **Passphrase verified** — wrong passphrase caught before decrypt attempt
+- **Local MCP server** — runs on your machine, no data sent to external services
 
 ## Requirements
 
@@ -262,7 +268,7 @@ memoir restore --profile team
 
 ## Contributing
 
-Contributions welcome — especially new tool adapters and migration improvements.
+Contributions welcome — especially new tool adapters and MCP improvements.
 
 1. Fork the repo
 2. Create your branch (`git checkout -b feature/my-feature`)

package/bin/memoir.js

@@ -16,7 +16,10 @@ 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 { shareCommand } from '../src/commands/share.js';
 import { historyCommand } from '../src/commands/history.js';
+import { projectsListCommand, projectsTodoCommand } from '../src/commands/projects.js';
+import { upgradeCommand } from '../src/commands/upgrade.js';
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
@@ -62,12 +65,15 @@ if (process.argv.length <= 2) {
     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 projects   ') + chalk.gray('— see all your projects at a glance') + '\n' +
     chalk.cyan('  memoir encrypt   ') + chalk.gray('— toggle E2E encryption') + '\n' +
-    chalk.cyan('  memoir update    ') + chalk.gray('— update to latest version') + '\n\n' +
+    chalk.cyan('  memoir update    ') + chalk.gray('— update to latest version') + '\n' +
+    chalk.cyan('  memoir upgrade   ') + chalk.gray('— view plans & upgrade') + '\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 share         ') + chalk.gray('— share memory via secure link') + '\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}`),
@@ -120,8 +126,9 @@ program
   .alias('pull')
   .description('Restore your AI memory on this machine')
   .option('--only <tools>', 'Only restore specific tools (comma-separated)')
-  .option('-y, --yes', 'Skip confirmation prompts (restore all)')
+  .option('-i, --interactive', 'Confirm each tool before restoring')
   .option('-p, --profile <name>', 'Use a specific profile')
+  .option('--from <token>', 'Restore from a share link token')
   .action(async (options) => {
     try {
       await restoreCommand(options);
@@ -131,6 +138,21 @@ program
     }
   });
 
+program
+  .command('share')
+  .description('Share your AI memory via a secure link')
+  .option('--only <tools>', 'Only share specific tools (comma-separated)')
+  .option('--expires <hours>', 'Link expiry in hours (default: 24)')
+  .option('--uses <number>', 'Max number of uses (default: 5)')
+  .action(async (options) => {
+    try {
+      await shareCommand(options);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error during share:'), err.message);
+      process.exit(1);
+    }
+  });
+
 program
   .command('status')
   .description('See what AI tools are on this machine')
@@ -219,7 +241,6 @@ program
 
 program
   .command('update')
-  .alias('upgrade')
   .description('Update memoir to the latest version')
   .action(async () => {
     try {
@@ -257,6 +278,19 @@ program
     }
   });
 
+program
+  .command('upgrade')
+  .alias('pro')
+  .description('View plans and upgrade your memoir subscription')
+  .action(async () => {
+    try {
+      await upgradeCommand();
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
 program
   .command('encrypt')
   .description('Toggle E2E encryption for your backups')
@@ -432,6 +466,47 @@ profile
     }
   });
 
+// Project tracker
+const projects = program.command('projects').alias('p').description('Track and manage your projects');
+
+projects
+  .command('list', { isDefault: true })
+  .alias('ls')
+  .description('List all projects with recent activity')
+  .option('--all', 'Show all projects (default: top 15)')
+  .option('-v, --verbose', 'Show more commits and todos')
+  .option('--json', 'Output as JSON')
+  .action(async (options) => {
+    try {
+      await projectsListCommand(options);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
+projects
+  .command('todo <project> [text]')
+  .description('Add or manage todos for a project')
+  .option('--done <index>', 'Mark a todo as done by number')
+  .option('--clear', 'Clear all todos for this project')
+  .action(async (project, text, options) => {
+    try {
+      await projectsTodoCommand(project, text, options);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('mcp')
+  .description('Start the MCP server (for Claude Code, Cursor, VS Code integration)')
+  .action(async () => {
+    // Import and run the MCP server directly
+    await import('../src/mcp.js');
+  });
+
 program.hook('postAction', async () => {
   await checkForUpdate();
 });