memoir-cli 2.6.0 → 3.0.1

package/bin/memoir.js

@@ -62,6 +62,7 @@ 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 encrypt   ') + chalk.gray('— toggle E2E encryption') + '\n' +
     chalk.cyan('  memoir update    ') + chalk.gray('— update to latest version') + '\n\n' +
     chalk.white.bold('Cloud (Pro):') + '\n' +
     chalk.cyan('  memoir login         ') + chalk.gray('— sign in to memoir cloud') + '\n' +
@@ -238,9 +239,8 @@ program
       console.log('\n' + chalk.cyan(`Updating memoir ${VERSION} → ${chalk.green.bold(latest)}...`) + '\n');
 
       const { execSync } = await import('child_process');
-      const execPath = process.argv[1] || '';
-      const useBun = execPath.includes('.bun') || process.env.BUN_INSTALL;
-      const cmd = useBun ? 'bun install -g memoir-cli' : 'npm install -g memoir-cli';
+      // Always use npm — bun installs to a different location and can cause PATH conflicts
+      const cmd = 'npm install -g memoir-cli';
 
       execSync(cmd, { stdio: 'inherit' });
 
@@ -257,6 +257,44 @@ program
     }
   });
 
+program
+  .command('encrypt')
+  .description('Toggle E2E encryption for your backups')
+  .action(async () => {
+    try {
+      const { getConfig, getRawConfig, saveConfig, migrateConfigToV2 } = await import('../src/config.js');
+      const config = await getConfig();
+      if (!config) {
+        console.error(chalk.red('\n✖ Not configured. Run memoir init first.'));
+        process.exit(1);
+      }
+      const current = config.encrypt || false;
+      console.log(chalk.white(`\n  Encryption is currently: ${current ? chalk.green('ON') : chalk.red('OFF')}`));
+      const inquirer = (await import('inquirer')).default;
+      const { toggle } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'toggle',
+        message: current ? 'Disable encryption?' : 'Enable encryption?',
+        default: !current
+      }]);
+      if (toggle !== current) {
+        let raw = await getRawConfig();
+        if (!raw.version || raw.version < 2) raw = migrateConfigToV2(raw);
+        const profileName = raw.activeProfile || 'default';
+        if (raw.profiles?.[profileName]) {
+          raw.profiles[profileName].encrypt = !current;
+        } else {
+          raw.encrypt = !current;
+        }
+        await saveConfig(raw);
+        console.log(chalk.green(`\n  ✔ Encryption ${!current ? 'enabled' : 'disabled'}. Next push will ${!current ? 'encrypt' : 'skip encryption'}.\n`));
+      }
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
 program
   .command('migrate')
   .description('Translate memory between AI tools (Claude, Gemini, Codex, Cursor, etc.)')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memoir-cli",
-  "version": "2.6.0",
+  "version": "3.0.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/adapters/index.js

@@ -3,6 +3,7 @@ import nodeFs from 'node:fs';
 import path from 'path';
 import os from 'os';
 import chalk from 'chalk';
+import { shouldIgnoreProject } from '../context/capture.js';
 
 const home = os.homedir();
 
@@ -332,7 +333,7 @@ export async function extractMemories(stagingDir, spinner, onlyFilter = null) {
         }
       }
 
-      if (foundFiles.length > 0 && dir !== home) {
+      if (foundFiles.length > 0 && dir !== home && !shouldIgnoreProject(dir)) {
         // This is a project with AI configs
         const projectName = path.basename(dir);
         const projectDestDir = path.join(projectsDest, projectName);

package/src/adapters/restore.js

@@ -9,7 +9,7 @@ import { adapters } from '../adapters/index.js';
 // on this machine, rather than trying to compute the encoding ourselves.
 // Claude's path encoding varies across platforms and versions, so detection
 // is the only reliable approach.
-function detectLocalHomeKey(adapterSource) {
+export function detectLocalHomeKey(adapterSource) {
   const localProjectsDir = path.join(adapterSource, 'projects');
   if (!fs.existsSync(localProjectsDir)) return null;
 
@@ -65,7 +65,14 @@ function remapProjectPaths(backupDir, adapterSource) {
   if (!localHomeKey) {
     const home = os.homedir();
     // Use the same encoding Claude uses: path with separators → dashes
-    localHomeKey = '-' + home.replace(/^\//, '').replace(/\\/g, '-').replace(/\//g, '-').replace(/:/g, '');
+    // Claude encodes paths: each separator (/ \ :) → dash
+    // macOS /Users/cam → -Users-cam (leading / stripped, prefixed with -)
+    // Windows C:\Users\X → C--Users-X (C + dash for colon + dash for backslash)
+    if (process.platform === 'win32') {
+      localHomeKey = home.replace(/\\/g, '-').replace(/:/g, '-');
+    } else {
+      localHomeKey = '-' + home.replace(/^\//, '').replace(/\//g, '-');
+    }
   }
 
   // Step 3: Identify foreign home keys in the backup

package/src/commands/push.js

@@ -9,9 +9,10 @@ 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 } from '../context/capture.js';
+import { findClaudeSessions, parseSession, generateContextHandoff, shouldIgnoreProject } 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';
 
 export async function pushCommand(options = {}) {
   const config = await getConfig(options.profile);
@@ -113,10 +114,42 @@ export async function pushCommand(options = {}) {
       }
     }
 
-    // Encrypt if enabled
+    // Encrypt if enabled (or ask on first push if not configured)
     let uploadDir = stagingDir;
     let encrypted = false;
-    if (config.encrypt) {
+    let shouldEncrypt = config.encrypt;
+
+    if (shouldEncrypt === undefined) {
+      // First push since encryption was added — ask once and save preference
+      spinner.stop();
+      const { wantEncrypt } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'wantEncrypt',
+        message: 'Enable E2E encryption? (protects your backup even if compromised)',
+        default: true
+      }]);
+      shouldEncrypt = wantEncrypt;
+
+      // Save to config so we don't ask again
+      try {
+        let raw = await getRawConfig();
+        if (raw) {
+          if (!raw.version || raw.version < 2) {
+            raw = migrateConfigToV2(raw);
+          }
+          const profileName = options.profile || raw.activeProfile || 'default';
+          if (raw.profiles?.[profileName]) {
+            raw.profiles[profileName].encrypt = shouldEncrypt;
+          } else {
+            raw.encrypt = shouldEncrypt;
+          }
+          await saveConfig(raw);
+        }
+      } catch {}
+      spinner.start();
+    }
+
+    if (shouldEncrypt) {
       spinner.stop();
       const { passphrase } = await inquirer.prompt([{
         type: 'password',
@@ -199,7 +232,7 @@ export async function pushCommand(options = {}) {
   } finally {
     await fs.remove(stagingDir);
     // Clean up encrypted dir if it was created
-    if (config.encrypt) {
+    if (true) {
       const encDirs = await fs.readdir(os.tmpdir());
       for (const d of encDirs) {
         if (d.startsWith('memoir-encrypted-')) {

package/src/commands/restore.js

@@ -9,6 +9,7 @@ import inquirer from 'inquirer';
 import { getConfig } from '../config.js';
 import { fetchFromLocal, fetchFromGit } from '../providers/restore.js';
 import { decryptDirectory, verifyPassphrase } from '../security/encryption.js';
+import { detectLocalHomeKey } from '../adapters/restore.js';
 
 const home = os.homedir();
 
@@ -135,21 +136,31 @@ export async function restoreCommand(options = {}) {
           await fs.writeFile(path.join(localHandoffDir, 'latest.md'), handoffContent);
 
           // Inject into Claude's home-level memory so it's always loaded
-          const cwdKey = '-' + home.replace(/^\//, '').replace(/\\/g, '-').replace(/\//g, '-').replace(/:/g, '');
-          const claudeMemDir = path.join(home, '.claude', 'projects', cwdKey, 'memory');
-          if (await fs.pathExists(path.join(home, '.claude'))) {
+          // Use detection (reads what Claude actually created) with corrected fallback
+          const claudeDir = path.join(home, '.claude');
+          if (await fs.pathExists(claudeDir)) {
+            let homeKey = detectLocalHomeKey(claudeDir);
+            if (!homeKey) {
+              // Fallback: compute key matching Claude's actual encoding
+              if (process.platform === 'win32') {
+                homeKey = home.replace(/\\/g, '-').replace(/:/g, '-');
+              } else {
+                homeKey = '-' + home.replace(/^\//, '').replace(/\//g, '-');
+              }
+            }
+            const claudeMemDir = path.join(claudeDir, 'projects', homeKey, 'memory');
             await fs.ensureDir(claudeMemDir);
             await fs.writeFile(path.join(claudeMemDir, 'handoff.md'), handoffContent);
             handoffInjected = true;
           }
 
-          // Extract info for display
-          const fromMatch = handoffContent.match(/\*\*From:\*\*\s*(.+)/);
-          const whenMatch = handoffContent.match(/\*\*When:\*\*\s*(.+)/);
-          const durationMatch = handoffContent.match(/\*\*Duration:\*\*\s*(.+)/);
+          // Extract info for display — handles both old and new handoff formats
+          const fromMatch = handoffContent.match(/\*\*From:\*\*\s*(.+)/) || handoffContent.match(/from \*\*(.+?)\*\*/);
+          const whenMatch = handoffContent.match(/\*\*When:\*\*\s*(.+)/) || handoffContent.match(/on (\d{4}-\d{2}-\d{2}) at (.+)/);
+          const durationMatch = handoffContent.match(/\*\*Duration:\*\*\s*(.+)/) || handoffContent.match(/Session: (\w+)/);
           handoffInfo = {
             from: fromMatch ? fromMatch[1] : 'another machine',
-            when: whenMatch ? whenMatch[1] : 'recently',
+            when: whenMatch ? (whenMatch[2] ? `${whenMatch[1]} ${whenMatch[2]}` : whenMatch[1]) : 'recently',
             duration: durationMatch ? durationMatch[1] : null,
           };
         }

package/src/commands/resume.js

@@ -51,7 +51,13 @@ async function injectHandoff(content, tool) {
     claude: () => {
       // Write to Claude's project memory dir so it's auto-loaded
       const cwd = process.cwd();
-      const cwdKey = '-' + cwd.replace(/^\//, '').replace(/\\/g, '-').replace(/\//g, '-').replace(/:/g, '');
+      // Match Claude's actual path encoding: each separator → dash
+      let cwdKey;
+      if (process.platform === 'win32') {
+        cwdKey = cwd.replace(/\\/g, '-').replace(/:/g, '-');
+      } else {
+        cwdKey = '-' + cwd.replace(/^\//, '').replace(/\//g, '-');
+      }
       const memDir = path.join(home, '.claude', 'projects', cwdKey, 'memory');
       return path.join(memDir, 'handoff.md');
     },

package/src/context/capture.js

@@ -168,47 +168,41 @@ export function generateContextHandoff(parsed) {
     .filter(m => m.length > 10 && !/^(ok|yes|no|sure|yea|yeah|yep|nah|nope|thanks|ty|thx|good|great|nice|cool|done|hmm)$/i.test(m.trim()))
     .map(m => m.length > 150 ? m.slice(0, 150) + '...' : m);
 
+  // Build a concise, actionable handoff
   let md = `---
 name: Session Handoff
-description: Auto-generated context from last coding session for seamless cross-device continuity
+description: Coding session context — resume on any machine, any AI tool
 type: project
 ---
 
-# Session Handoff
+# Continue where I left off
 
-**From:** ${hostname} (${platform})
-**When:** ${now.toISOString().split('T')[0]} ${now.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' })}
-**Duration:** ${duration}
-**Project:** ${cwd}
-**Branch:** ${parsed.gitBranch || 'unknown'}
+> Handed off from **${hostname}** (${platform}) on ${now.toISOString().split('T')[0]} at ${now.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' })}
+> Session: ${duration} | Branch: \`${parsed.gitBranch || 'unknown'}\` | Project: \`${cwd}\`
 
-## What was being worked on
+## What I was working on
 ${meaningful.length > 0 ? meaningful.slice(0, 8).map(m => `- ${m}`).join('\n') : '_No significant messages captured_'}
 
-## Files modified
+## Files I changed
 ${parsed.filesWritten.length > 0
     ? parsed.filesWritten.slice(0, 15).map(f => `- \`${shorten(f)}\``).join('\n')
     : '_None_'}
-
-## Key files referenced
-${parsed.filesRead.length > 0
-    ? parsed.filesRead.filter(f => !parsed.filesWritten.includes(f)).slice(0, 10).map(f => `- \`${shorten(f)}\``).join('\n')
-    : '_None_'}
 `;
 
-  if (parsed.errors.length > 0) {
-    md += `\n## Errors hit\n${parsed.errors.slice(0, 5).map(e => `- ${e}`).join('\n')}\n`;
+  // Only show referenced files that weren't also modified
+  const readOnly = parsed.filesRead.filter(f => !parsed.filesWritten.includes(f));
+  if (readOnly.length > 0) {
+    md += `\n## Files I was looking at\n${readOnly.slice(0, 10).map(f => `- \`${shorten(f)}\``).join('\n')}\n`;
   }
 
-  md += `\n## Context for continuing
-This session ran for ${duration} on ${platform}. ${parsed.filesWritten.length} files were modified and ${parsed.bashCommands.length} commands were run.`;
+  if (parsed.errors.length > 0) {
+    md += `\n## Issues I ran into\n${parsed.errors.slice(0, 5).map(e => `- ${e}`).join('\n')}\n`;
+  }
 
   if (parsed.filesWritten.length > 0) {
-    md += ` Start by reviewing: ${parsed.filesWritten.slice(0, 3).map(f => '`' + shorten(f) + '`').join(', ')}.`;
+    md += `\n## Pick up here\nStart by reviewing: ${parsed.filesWritten.slice(0, 3).map(f => '`' + shorten(f) + '`').join(', ')}. ${parsed.filesWritten.length} files were modified in total.\n`;
   }
 
-  md += '\n';
-
   return md;
 }