memoir-cli 3.1.0 → 3.1.1

package/README.md

@@ -2,43 +2,59 @@
 
 # memoir
 
-**Sync your AI memory across every device and every tool.**
+**Your AI remembers everything. On every machine.**
 
 [![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)
 
-Your AI tools forget you on every new machine. memoir fixes that.
+Close your laptop. Open another one. **Your AI picks up exactly where you left off.**
 
 [Website](https://memoir.sh) • [npm](https://npmjs.org/package/memoir-cli) • [Blog](https://memoir.sh/blog)
 
 <br />
 
-![memoir demo](demo.gif)
-
 </div>
 
-## Why memoir
+## The Problem
 
-You spend weeks teaching your AI tools how you code. Your CLAUDE.md is dialed in. Your .cursorrules are perfect. Your ChatGPT custom instructions know your stack.
+You spend weeks teaching Claude how you code. Your projects are dialed in. Your AI knows your stack, your decisions, your preferences.
 
-Then you get a new laptop. **Everything is gone.**
+Then you switch machines. **Everything is gone.** Your AI has amnesia. Your projects aren't there. You start from zero.
 
-memoir backs up, restores, and **translates** your AI memory across any machine and any tool. One command to save. One command to restore.
+## The Fix
 
 ```bash
+# On your main machine
+memoir push
+
+# On any other machine
 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
 ```
 
-## Supported Tools (11)
+One command to save. One command to restore. That's it.
+
+## 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.
 
 | Tool | What gets synced |
 |------|-----------------|
-| **ChatGPT** | CHATGPT.md custom instructions |
 | **Claude Code** | ~/.claude/ settings, memory, CLAUDE.md files |
 | **Gemini CLI** | ~/.gemini/ config, GEMINI.md files |
-| **OpenAI Codex** | ~/.codex/ config, AGENTS.md, codex.md |
+| **ChatGPT** | CHATGPT.md custom instructions |
+| **OpenAI Codex** | ~/.codex/ config, AGENTS.md |
 | **Cursor** | Settings, keybindings, .cursorrules |
 | **GitHub Copilot** | Config, copilot-instructions.md |
 | **Windsurf** | Settings, keybindings, .windsurfrules |
@@ -47,7 +63,37 @@ npm install -g memoir-cli
 | **Continue.dev** | Config, .continuerules |
 | **Aider** | .aider.conf.yml, system prompt |
 
-Plus **per-project configs** — memoir scans your filesystem for CLAUDE.md, GEMINI.md, CHATGPT.md, .cursorrules, and AGENTS.md across all your projects.
+### Layer 2: Session State
+What you were **doing** — not just what your AI knows, but the active context.
+
+- Last coding session captured automatically
+- What files you changed, what errors you hit, what decisions you made
+- 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)
+Your actual projects — code, files, everything.
+
+- **Git projects:** Remote URLs saved, auto-cloned on restore
+- **Non-git projects:** Bundled as compressed archives, unpacked on restore
+- **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
 
@@ -55,41 +101,52 @@ Plus **per-project configs** — memoir scans your filesystem for CLAUDE.md, GEM
 # Install
 npm install -g memoir-cli
 
-# First-time setup (GitHub repo or local)
+# First-time setup
 memoir init
 
-# Back up all your AI configs
+# Back up everything
 memoir push
 
-# Restore on a new machine
+# Restore on any machine
 memoir restore
 ```
 
-That's it. Every AI tool gets its memory back.
-
 ## Key Features
 
-### Translate between AI tools
+### Workspace sync
 ```bash
-memoir migrate --from chatgpt --to claude
-# AI-powered — rewrites conventions, not copy-paste
+memoir push     # scans all projects, saves git URLs + bundles non-git projects
+memoir restore  # auto-clones repos, unpacks bundles, applies uncommitted patches
 ```
 
-Works between any combination: ChatGPT, Claude, Gemini, Cursor, Copilot, Codex, Windsurf, Aider, and more. Translate to one tool or all at once:
+No manual git commands. memoir detects your projects, tracks their remotes, and restores them anywhere.
 
+### Translate between AI tools
 ```bash
+memoir migrate --from chatgpt --to claude
+# AI-powered — rewrites conventions, not copy-paste
+
 memoir migrate --from chatgpt --to all
+# Translate to every tool at once
 ```
 
 ### Session handoff
 ```bash
-# Laptop dying? Capture your session
+# Capture your session (automatic on push, or manual)
 memoir snapshot
 
 # Pick up on another machine
 memoir resume --inject --to claude
 ```
 
+### E2E Encryption
+```bash
+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.
+
 ### Profiles (personal / work)
 ```bash
 memoir profile create work
@@ -107,23 +164,24 @@ memoir cloud restore   # restore from any version
 memoir history         # view all backup versions
 ```
 
-Free tier: 3 cloud backups. Pro ($5/mo): unlimited + version history.
-
-### Security
+### Cross-platform (Mac / Windows / Linux)
 ```bash
-memoir doctor
-# Scans for secrets, API keys, .env files before pushing
+# Push from Mac
+memoir push
+
+# Restore on Windows — paths remap automatically
+memoir restore
 ```
 
-memoir **never** syncs credentials, API keys, .env files, or auth tokens.
+Claude's memory paths are automatically remapped between platforms. Projects are cloned to the right locations. It just works.
 
 ## All Commands
 
 | Command | What it does |
 |---------|-------------|
 | `memoir init` | Setup wizard — GitHub or local storage |
-| `memoir push` | Back up all AI configs |
-| `memoir restore` | Restore on a new machine |
+| `memoir push` | Back up AI memory + workspace + session |
+| `memoir restore` | Restore everything on a new machine |
 | `memoir status` | Show detected AI tools |
 | `memoir doctor` | Diagnose issues, scan for secrets |
 | `memoir view` | Preview what's in your backup |
@@ -131,6 +189,7 @@ memoir **never** syncs credentials, API keys, .env files, or auth tokens.
 | `memoir migrate` | Translate memory between tools via AI |
 | `memoir snapshot` | Capture current coding session |
 | `memoir resume` | Pick up where you left off |
+| `memoir encrypt` | Toggle E2E encryption |
 | `memoir profile` | Manage profiles (personal/work) |
 | `memoir cloud push` | Back up to memoir cloud |
 | `memoir cloud restore` | Restore from memoir cloud |
@@ -140,57 +199,65 @@ memoir **never** syncs credentials, API keys, .env files, or auth tokens.
 
 ## How memoir compares
 
-| Feature | memoir | skillshare | ai-rulez | memories.sh |
-|---------|--------|-----------|----------|-------------|
-| Cross-device sync | **Yes** | Yes (git) | No | Yes |
+| Feature | memoir | dotfiles managers | ai-rulez | memories.sh |
+|---------|--------|-------------------|----------|-------------|
+| AI memory sync | **11 tools** | No | 18 tools | 3 tools |
+| Workspace sync | **Yes** | No | No | No |
+| Session handoff | **Yes** | No | No | No |
 | AI-powered translation | **Yes** | No | No | No |
-| Tools supported | **11** | 40+ | 18 | 3 |
+| 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) |
-| Version history | **Yes** | No | No | No |
-| Session handoff | **Yes** | No | No | No |
 | Profiles | **Yes** | No | No | No |
-| Secret scanning | **Yes** | Yes | No | No |
 | Free & open source | **Yes** | Yes | Yes | No |
 
-memoir is free and open source. Cloud sync starts at $0 (3 backups free).
-
 ## Common Workflows
 
-### New laptop setup
+### New machine setup
 ```bash
 # Old machine
 memoir push
 
-# New machine
-npm install -g memoir-cli
-memoir init      # connect to same repo
-memoir restore   # all configs restored in seconds
+# New machine — one command, everything's back
+npm install -g memoir-cli && memoir init && memoir restore -y
 ```
 
-### Switching from ChatGPT to Claude
+### Daily sync between machines
 ```bash
-memoir migrate --from chatgpt --to claude
-# Your custom instructions become a proper CLAUDE.md
+memoir push      # end of day on laptop
+memoir restore   # next morning on desktop — AI knows what you were doing
 ```
 
-### Daily sync between machines
+### Switching AI tools
 ```bash
-memoir push      # end of day on laptop
-memoir restore   # next morning on desktop
+memoir migrate --from chatgpt --to claude
+# Your custom instructions become a proper CLAUDE.md
 ```
 
-### Cross-platform (Mac ↔ Windows ↔ Linux)
+### Team onboarding
 ```bash
-# Push from Mac
-memoir push
+# Senior dev pushes team config
+memoir push --profile team
 
-# Restore on Windows — paths remap automatically
-memoir restore
+# New hire runs one command
+memoir restore --profile team
+# Every project cloned. Every AI tool configured. Day one productive.
 ```
 
+## Security
+
+- **E2E encryption** — AES-256-GCM with scrypt key derivation
+- **Secret scanning** — 20+ patterns detect API keys, tokens, passwords, connection strings
+- **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
+
 ## Requirements
 
 - Node.js >= 18
+- Git (for workspace sync)
 - Works on macOS, Windows, Linux
 
 ## Contributing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memoir-cli",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "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",

package/src/commands/push.js

@@ -9,7 +9,7 @@ import { getConfig } from '../config.js';
 import { extractMemories, adapters } from '../adapters/index.js';
 import { syncToLocal, syncToGit } from '../providers/index.js';
 import inquirer from 'inquirer';
-import { findClaudeSessions, parseSession, generateContextHandoff, shouldIgnoreProject } from '../context/capture.js';
+import { findClaudeSessions, parseSession, generateContextHandoff, shouldIgnoreProject, persistDecisions } from '../context/capture.js';
 import { scanForSecrets, printSecurityReport } from '../security/scanner.js';
 import { encryptDirectory, createVerifyToken } from '../security/encryption.js';
 import { getRawConfig, saveConfig, migrateConfigToV2 } from '../config.js';
@@ -77,10 +77,19 @@ export async function pushCommand(options = {}) {
           await fs.writeFile(path.join(localHandoffDir, `${timestamp}-claude.md`), clean);
           await fs.writeFile(path.join(localHandoffDir, 'latest.md'), clean);
 
+          // Persist decisions to Claude's memory so they survive across sessions
+          let decisionCount = 0;
+          if (parsed.decisions.length > 0) {
+            try {
+              decisionCount = persistDecisions(parsed.decisions);
+            } catch {}
+          }
+
           contextCaptured = true;
           sessionInfo = {
             slug: parsed.slug,
             filesModified: parsed.filesWritten.length,
+            decisions: decisionCount,
             duration: parsed.firstTimestamp && parsed.lastTimestamp
               ? (() => {
                   const ms = new Date(parsed.lastTimestamp) - new Date(parsed.firstTimestamp);
@@ -226,6 +235,9 @@ export async function pushCommand(options = {}) {
       if (sessionInfo.duration) parts.push(sessionInfo.duration);
       if (sessionInfo.filesModified) parts.push(`${sessionInfo.filesModified} files changed`);
       contextLine = '\n' + chalk.green('  ✔ Session Context') + chalk.gray(` (${parts.join(', ')})`) + '\n';
+      if (sessionInfo.decisions > 0) {
+        contextLine += chalk.green(`  ✔ ${sessionInfo.decisions} decision(s) saved to persistent memory`) + '\n';
+      }
       if (sessionInfo.secretsRedacted > 0) {
         contextLine += chalk.yellow(`  🔒 ${sessionInfo.secretsRedacted} secret(s) auto-redacted`) + '\n';
       }

package/src/context/capture.js

@@ -61,6 +61,7 @@ export function parseSession(sessionPath, maxSizeMB = 10) {
 }
 
 function parseLines(lines) {
+  const assistantTexts = [];
   const result = {
     sessionId: null,
     slug: null,
@@ -95,9 +96,14 @@ function parseLines(lines) {
       }
     }
 
-    // Tool uses from assistant
+    // Tool uses and text from assistant
     if (obj.type === 'assistant' && Array.isArray(obj.message?.content)) {
       for (const block of obj.message.content) {
+        if (block.type === 'text' && block.text) {
+          // Capture assistant text for decision extraction (limit size)
+          if (block.text.length < 2000) assistantTexts.push(block.text);
+          continue;
+        }
         if (block.type !== 'tool_use') continue;
         const name = block.name;
         const input = block.input || {};
@@ -139,9 +145,148 @@ function parseLines(lines) {
   result.filesRead = [...result.filesRead];
   result.errors = [...new Set(result.errors)].slice(0, 10);
 
+  // Extract decisions from user + assistant messages
+  result.decisions = extractDecisions(result.userMessages, assistantTexts);
+
   return result;
 }
 
+/**
+ * Extract durable decisions from session conversation.
+ * These are things like renames, tech choices, preferences — stuff that should persist.
+ */
+function extractDecisions(userMessages, assistantTexts) {
+  const decisions = [];
+  const allText = [...userMessages, ...assistantTexts].join('\n');
+
+  // Patterns that indicate a decision was made
+  const patterns = [
+    // Renames / naming
+    { regex: /(?:rename|call|name)\s+(?:it|this|the (?:project|app|tool|product))\s+(?:to\s+)?["']?([A-Z][a-zA-Z0-9_-]+)["']?/gi, type: 'rename' },
+    { regex: /(?:the\s+)?(?:new\s+)?name\s+(?:is|will be|should be)\s+["']?([A-Z][a-zA-Z0-9_-]+)["']?/gi, type: 'rename' },
+    { regex: /(?:rebrand|rebranding)\s+(?:to|as)\s+["']?([A-Z][a-zA-Z0-9_-]+)["']?/gi, type: 'rename' },
+    // Tech choices
+    { regex: /(?:let'?s|we(?:'ll| will| should)?|going to|decided to)\s+use\s+([A-Z][a-zA-Z0-9_./-]+)\s+(?:for|instead|as|to)/gi, type: 'tech' },
+    { regex: /(?:switch|migrate|move)\s+(?:from\s+\S+\s+)?to\s+([A-Z][a-zA-Z0-9_./-]+)/gi, type: 'tech' },
+    // Architecture / design
+    { regex: /(?:let'?s|we(?:'ll| will| should)?)\s+(?:go with|pick|choose)\s+(.{5,60}?)(?:\.|$|,|\n)/gi, type: 'design' },
+    // Stack choices
+    { regex: /(?:stack|framework|database|backend|frontend)\s+(?:is|will be|should be)\s+(.{5,60}?)(?:\.|$|,|\n)/gi, type: 'stack' },
+  ];
+
+  for (const { regex, type } of patterns) {
+    let match;
+    while ((match = regex.exec(allText)) !== null) {
+      const value = match[1].trim().replace(/["']+$/, '');
+      if (value.length > 2 && value.length < 80) {
+        // Avoid duplicates
+        const existing = decisions.find(d => d.value.toLowerCase() === value.toLowerCase());
+        if (!existing) {
+          decisions.push({ type, value, context: match[0].trim().slice(0, 120) });
+        }
+      }
+    }
+  }
+
+  // Look for explicit "remember this" instructions from the user
+  for (const msg of userMessages) {
+    // Only match when user is clearly asking to remember something
+    const rememberMatch = msg.match(/(?:remember (?:that|this)|note that|keep in mind that|from now on)[:\s]+(.{10,150})/i);
+    if (rememberMatch) {
+      decisions.push({ type: 'user-note', value: rememberMatch[1].trim(), context: msg.slice(0, 120) });
+    }
+  }
+
+  return decisions.slice(0, 20); // Cap at 20 decisions per session
+}
+
+/**
+ * Write extracted decisions to Claude's persistent memory.
+ * This ensures decisions survive across sessions and machines.
+ */
+export function persistDecisions(decisions, claudeSource) {
+  if (!decisions || decisions.length === 0) return 0;
+
+  const claudeDir = claudeSource || path.join(home, '.claude');
+  const projectsDir = path.join(claudeDir, 'projects');
+  if (!fs.existsSync(projectsDir)) return 0;
+
+  // Find the HOME-level memory dir (not project-specific)
+  // This is the dir that matches the user's home path encoding
+  let homeKey;
+  if (process.platform === 'win32') {
+    homeKey = home.replace(/\\/g, '-').replace(/:/g, '-');
+  } else {
+    homeKey = '-' + home.replace(/^\//, '').replace(/\//g, '-');
+  }
+
+  // Try exact match first, then detect from existing dirs
+  let memDir = path.join(projectsDir, homeKey, 'memory');
+  if (!fs.existsSync(memDir)) {
+    // Fallback: find dirs with memory/ subfolder, pick shortest name (likely home-level)
+    const entries = fs.readdirSync(projectsDir, { withFileTypes: true })
+      .filter(e => e.isDirectory() && fs.existsSync(path.join(projectsDir, e.name, 'memory')));
+    if (entries.length === 0) return 0;
+    // Shortest dir name is most likely the home key (not a sub-project)
+    const homeEntry = entries.sort((a, b) => a.name.length - b.name.length)[0];
+    memDir = path.join(projectsDir, homeEntry.name, 'memory');
+  }
+
+  fs.mkdirSync(memDir, { recursive: true });
+  const decisionsFile = path.join(memDir, 'session-decisions.md');
+  const memoryMdPath = path.join(memDir, 'MEMORY.md');
+
+  // Read existing decisions file or create new
+  let existing = '';
+  if (fs.existsSync(decisionsFile)) {
+    existing = fs.readFileSync(decisionsFile, 'utf8');
+  }
+
+  // Format new decisions
+  const date = new Date().toISOString().split('T')[0];
+  const newEntries = decisions.map(d => {
+    if (d.type === 'rename') return `- **Renamed:** ${d.context}`;
+    if (d.type === 'tech') return `- **Tech choice:** ${d.context}`;
+    if (d.type === 'design') return `- **Decision:** ${d.context}`;
+    if (d.type === 'stack') return `- **Stack:** ${d.context}`;
+    if (d.type === 'user-note') return `- **Note:** ${d.value}`;
+    return `- ${d.context}`;
+  });
+
+  // Check for duplicates against existing content
+  const fresh = newEntries.filter(entry => !existing.includes(entry));
+  if (fresh.length === 0) return 0;
+
+  const section = `\n### ${date}\n${fresh.join('\n')}\n`;
+
+  if (!existing) {
+    // Create new file with frontmatter
+    const content = `---
+name: Session Decisions
+description: Project decisions extracted from coding sessions — renames, tech choices, architecture
+type: project
+---
+
+# Decisions from coding sessions
+${section}`;
+    fs.writeFileSync(decisionsFile, content);
+  } else {
+    // Append to existing
+    fs.writeFileSync(decisionsFile, existing.trimEnd() + '\n' + section);
+  }
+
+  // Ensure MEMORY.md references the decisions file
+  if (fs.existsSync(memoryMdPath)) {
+    const memoryMd = fs.readFileSync(memoryMdPath, 'utf8');
+    if (!memoryMd.includes('session-decisions.md')) {
+      const addition = `\n- [Session Decisions](session-decisions.md) — project renames, tech choices, architecture decisions from coding sessions\n`;
+      fs.writeFileSync(memoryMdPath, memoryMd.trimEnd() + addition);
+    }
+  }
+
+  return fresh.length;
+}
+
 /**
  * Generate a concise handoff markdown from parsed session
  * This is what gets injected into the AI tool on the other machine