memoir-cli 1.4.5 → 1.5.1

package/CLAUDE.md

@@ -0,0 +1 @@
+Old Claude Instructions

package/TODO.md

@@ -0,0 +1,39 @@
+# memoir Roadmap & TODO
+
+This list tracks planned features, identified bugs, and architectural improvements for the `memoir` CLI.
+
+## 🔴 High Priority: Security, Reliability & Bug Fixes
+- [ ] **`memoir doctor` Command:** Implement a diagnostic utility to verify:
+    - [ ] Correct installation of supported AI tools (Claude, Cursor, etc.).
+    - [ ] File permissions for all memory directories.
+    - [ ] Git connectivity and API key validity (Gemini).
+    - [ ] Environment variable health.
+- [ ] **Secret & PII Guard:** Add a pre-push scan to detect API keys or PII in memory files. Implement a `redact` flag.
+- [ ] **Linux Path Support:** Add path detection for Cursor and Windsurf on Linux (currently macOS/Windows only).
+- [ ] **Aider Local Discovery:** Update the Aider adapter to look for `.aider/` in the current project repo, not just global config.
+- [ ] **Robust Claude Pathing:** Replace fragile string-replacement in `src/tools/claude.js` with more reliable hashing/matching for `~/.claude/projects`.
+- [ ] **Add `-y` / `--yes` Flags:** Enable non-interactive mode for `push`, `restore`, and `migrate` to support automation.
+
+## 🟡 Medium Priority: UX & Workflow
+- [ ] **Local LLM Migration (Privacy):**
+    - [ ] Add support for **Ollama** and **LM Studio** as translation engines in `migrate`.
+    - [ ] Add a `--local` flag to `migrate` to bypass external APIs.
+- [ ] **`memoir watch` (Background Sync):** Create a lightweight daemon to detect changes in local memory files and trigger auto-sync.
+- [ ] **Project Bootstrapping (`memoir init --template`):** Seed new projects with "Golden Rule" templates (e.g., "Strict TypeScript," "React/Tailwind Best Practices").
+- [ ] **Interactive Merge/Diff:** Replace "Overwrite/Append" in `migrate` with a side-by-side diff view.
+- [ ] **Silent Mode:** Add a `--silent` flag to suppress all output except errors.
+
+## 🟢 Low Priority: Intelligence & Advanced Features
+- [ ] **Unified Memory Format (UMF):** Architect an internal JSON schema to represent "Coding Context" to simplify adding new tool adapters.
+- [ ] **Cross-Tool Search:** Implement `memoir search <query>` to find specific instructions across all tool backups.
+- [ ] **Context Compression:** AI-powered `memoir optimize` command to summarize long instruction files and save tokens.
+- [ ] **Organization Sync:** Support for shared "Team Memories" stored in a central repository.
+- [ ] **Memory Analytics:** `memoir stats` to visualize the growth and "personality" of your AI instructions over time.
+
+---
+
+## 📝 Technical Observations & Bug Log
+*   **Circular Dependency:** `package.json` lists `memoir-cli` as its own dependency. Needs cleanup.
+*   **Git Performance:** `push` currently clones the entire repo every time. Optimize with `git clone --depth 1` or local cache.
+*   **Performance:** Refactor `fs.readFileSync` inside loops (e.g., in `src/tools/claude.js`) to use `fs.promises` for better handling of large projects.
+*   **CLI Friction:** The `migrate` command's interactive prompt for multiple files can be tedious; batching confirmations would improve UX.

package/bin/memoir.js

@@ -14,6 +14,22 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const { version: VERSION } = require('../package.json');
 
+// Show quick start when run with no args
+if (process.argv.length <= 2) {
+  console.log('\n' + boxen(
+    gradient.pastel.multiline('  memoir  ') + '\n' +
+    chalk.gray('  Your AI remembers everything.') + '\n\n' +
+    chalk.white.bold('Quick Start:') + '\n' +
+    chalk.cyan('  memoir init     ') + chalk.gray('— first-time setup') + '\n' +
+    chalk.cyan('  memoir push     ') + chalk.gray('— back up your AI memory') + '\n' +
+    chalk.cyan('  memoir restore  ') + chalk.gray('— restore on a new machine') + '\n' +
+    chalk.cyan('  memoir status   ') + chalk.gray('— see detected AI tools') + '\n\n' +
+    chalk.gray(`v${VERSION}`),
+    { padding: 1, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
+  ) + '\n');
+  process.exit(0);
+}
+
 // Custom help banner
 program.addHelpText('beforeAll', '\n' + boxen(
   gradient.pastel.multiline('  memoir  ') + '\n' +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memoir-cli",
-  "version": "1.4.5",
+  "version": "1.5.1",
   "description": "Sync and translate AI memory across devices and tools. Back up Claude, Gemini, Codex, Cursor, Copilot, Windsurf, and Aider configs. Migrate instructions between AI coding assistants with one command.",
   "main": "src/index.js",
   "type": "module",
@@ -55,7 +55,7 @@
     "fs-extra": "^11.2.0",
     "gradient-string": "^3.0.0",
     "inquirer": "^9.2.15",
-    "memoir-cli": "^1.4.4",
+
     "open": "^11.0.0",
     "ora": "^7.0.1"
   }

package/src/adapters/index.js

@@ -1,4 +1,5 @@
 import fs from 'fs-extra';
+import nodeFs from 'node:fs';
 import path from 'path';
 import os from 'os';
 import chalk from 'chalk';
@@ -14,18 +15,42 @@ export const adapters = [
     icon: '🔵',
     source: path.join(home, '.gemini'),
     filter: (src) => {
+      const geminiDir = path.join(home, '.gemini');
+      const rel = path.relative(geminiDir, src);
+      if (src === geminiDir) return true;
+      // Only sync config/settings files — skip caches, history, auth, sandbox, etc.
+      const allowed = ['settings.json', 'projects.json', 'state.json', 'installation_id', 'trustedFolders.json', '.gitignore', 'GEMINI.md'];
       const basename = path.basename(src);
-      const ignored = ['.git', 'oauth_creds.json', 'google_accounts.json', 'tmp', 'history'];
-      return !ignored.includes(basename);
+      return allowed.includes(basename) && !rel.includes(path.sep);
     }
   },
   {
     name: 'Claude CLI',
     icon: '🟣',
     source: path.join(home, '.claude'),
-    filter: (src) => {
+    filter: (src, dest) => {
       const basename = path.basename(src);
-      return !basename.endsWith('.key') && basename !== '.env';
+      const claudeDir = path.join(home, '.claude');
+      const rel = path.relative(claudeDir, src);
+      // Root dir itself
+      if (src === claudeDir) return true;
+      // Only allow these top-level dirs
+      const topDir = rel.split(path.sep)[0];
+      const allowedDirs = ['projects', 'settings'];
+      const allowedFiles = ['settings.json', 'settings.local.json'];
+      // Allow specific top-level config files
+      if (!rel.includes(path.sep) && allowedFiles.includes(basename)) return true;
+      // Allow projects dir (contains memory .md files)
+      if (topDir === 'projects') {
+        // Allow directory traversal
+        try { if (nodeFs.statSync(src).isDirectory()) return true; } catch {}
+        // Only sync memory markdown files
+        return basename.endsWith('.md');
+      }
+      // Allow settings dir
+      if (topDir === 'settings') return true;
+      // Block everything else
+      return false;
     }
   },
   {
@@ -33,9 +58,13 @@ export const adapters = [
     icon: '🟢',
     source: path.join(home, '.codex'),
     filter: (src) => {
+      const codexDir = path.join(home, '.codex');
+      const rel = path.relative(codexDir, src);
+      if (src === codexDir) return true;
       const basename = path.basename(src);
-      const ignored = ['.git', 'sessions', 'cache'];
-      return !ignored.includes(basename) && !basename.endsWith('.key') && basename !== '.env';
+      // Only sync config files
+      const allowed = ['config.json', 'settings.json', 'instructions.md'];
+      return allowed.includes(basename) && !rel.includes(path.sep);
     }
   },
   {
@@ -45,9 +74,19 @@ export const adapters = [
       ? path.join(appData, 'Cursor', 'User')
       : path.join(home, 'Library', 'Application Support', 'Cursor', 'User'),
     filter: (src) => {
+      const cursorDir = isWin
+        ? path.join(appData, 'Cursor', 'User')
+        : path.join(home, 'Library', 'Application Support', 'Cursor', 'User');
+      const rel = path.relative(cursorDir, src);
+      if (src === cursorDir) return true;
       const basename = path.basename(src);
-      const ignored = ['globalStorage', 'workspaceStorage', 'CachedData', 'Cache', 'GPUCache', 'logs', 'History', 'Backups', 'snippets'];
-      return !ignored.includes(basename);
+      // Only sync settings and keybindings — not extensions, cache, storage
+      const allowed = ['settings.json', 'keybindings.json', 'rules'];
+      const topDir = rel.split(path.sep)[0];
+      if (allowed.includes(basename) && !rel.includes(path.sep)) return true;
+      // Allow rules directory (cursor rules)
+      if (topDir === 'rules') return true;
+      return false;
     }
   },
   {
@@ -57,9 +96,14 @@ export const adapters = [
       ? path.join(appData, 'GitHub Copilot')
       : path.join(home, '.config', 'github-copilot'),
     filter: (src) => {
+      const copilotDir = isWin
+        ? path.join(appData, 'GitHub Copilot')
+        : path.join(home, '.config', 'github-copilot');
+      if (src === copilotDir) return true;
       const basename = path.basename(src);
-      const ignored = ['hosts.json', 'apps.json', 'versions.json'];
-      return !ignored.includes(basename);
+      // Only sync config — skip auth tokens and version files
+      const allowed = ['settings.json', 'config.json'];
+      return allowed.includes(basename);
     }
   },
   {
@@ -69,9 +113,18 @@ export const adapters = [
       ? path.join(appData, 'Windsurf', 'User')
       : path.join(home, 'Library', 'Application Support', 'Windsurf', 'User'),
     filter: (src) => {
+      const windsurfDir = isWin
+        ? path.join(appData, 'Windsurf', 'User')
+        : path.join(home, 'Library', 'Application Support', 'Windsurf', 'User');
+      const rel = path.relative(windsurfDir, src);
+      if (src === windsurfDir) return true;
       const basename = path.basename(src);
-      const ignored = ['workspaceStorage', 'CachedData', 'Cache', 'GPUCache', 'logs', 'History', 'Backups', 'memories', 'snippets'];
-      return !ignored.includes(basename);
+      // Only sync settings and keybindings
+      const allowed = ['settings.json', 'keybindings.json', 'rules'];
+      const topDir = rel.split(path.sep)[0];
+      if (allowed.includes(basename) && !rel.includes(path.sep)) return true;
+      if (topDir === 'rules') return true;
+      return false;
     }
   },
   {

package/src/adapters/restore.js

@@ -5,7 +5,30 @@ import os from 'os';
 import inquirer from 'inquirer';
 import { adapters } from '../adapters/index.js';
 
-async function copyMissing(src, dest, changes) {
+// Claude CLI stores projects under paths like `projects/-Users-camarthur/`
+// This converts the path from the backup machine to match the current machine
+function remapProjectPath(backupDir, adapterSource) {
+  const projectsDir = path.join(backupDir, 'projects');
+  if (!fs.existsSync(projectsDir)) return null;
+
+  const entries = fs.readdirSync(projectsDir);
+  // Find the backed-up home dir key (e.g., "-Users-camarthur")
+  const oldHomeKey = entries.find(e => {
+    return fs.statSync(path.join(projectsDir, e)).isDirectory();
+  });
+  if (!oldHomeKey) return null;
+
+  // Build the current machine's home dir key
+  // Claude uses the homedir path with / replaced by - and leading -
+  const home = os.homedir();
+  const newHomeKey = '-' + home.replace(/^\//, '').replace(/\\/g, '-').replace(/\//g, '-').replace(/:/g, '');
+
+  if (oldHomeKey === newHomeKey) return null; // Same machine, no remap needed
+
+  return { oldHomeKey, newHomeKey };
+}
+
+async function syncFiles(src, dest, changes) {
   const entries = await fs.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = path.join(src, entry.name);
@@ -13,10 +36,18 @@ async function copyMissing(src, dest, changes) {
 
     if (entry.isDirectory()) {
       await fs.ensureDir(destPath);
-      await copyMissing(srcPath, destPath, changes);
+      await syncFiles(srcPath, destPath, changes);
     } else {
       if (await fs.pathExists(destPath)) {
-        changes.skipped.push(destPath);
+        // Compare modification times — update if backup is newer
+        const srcStat = await fs.stat(srcPath);
+        const destStat = await fs.stat(destPath);
+        if (srcStat.mtimeMs > destStat.mtimeMs) {
+          await fs.copy(srcPath, destPath);
+          changes.updated.push(destPath);
+        } else {
+          changes.skipped.push(destPath);
+        }
       } else {
         await fs.copy(srcPath, destPath);
         changes.added.push(destPath);
@@ -27,6 +58,7 @@ async function copyMissing(src, dest, changes) {
 
 export async function restoreMemories(sourceDir, spinner) {
   let restoredAny = false;
+  const allResults = [];
 
   for (const adapter of adapters) {
     const backupDir = path.join(sourceDir, adapter.name.toLowerCase().replace(/ /g, '-'));
@@ -34,61 +66,103 @@ export async function restoreMemories(sourceDir, spinner) {
     if (await fs.pathExists(backupDir)) {
       spinner.stop();
 
-      console.log('\n' + chalk.yellow(`⚠ Found backup for ${chalk.bold(adapter.name)}.`));
+      console.log('\n' + chalk.cyan(`${adapter.icon} Found backup for ${chalk.bold(adapter.name)}`));
+      console.log(chalk.gray(`  Will restore to: ${adapter.source}`));
       const { confirm } = await inquirer.prompt([
         {
           type: 'confirm',
           name: 'confirm',
-          message: `Restore ${adapter.name} memory? (only adds missing files, won't overwrite)`,
-          default: false
+          message: `Restore ${adapter.name}?`,
+          default: true
         }
       ]);
 
       spinner.start();
 
       if (confirm) {
-        const changes = { added: [], skipped: [] };
+        const changes = { added: [], updated: [], skipped: [] };
+
+        // Remap Claude project paths from source machine to this machine
+        if (adapter.name === 'Claude CLI') {
+          const remap = remapProjectPath(backupDir, adapter.source);
+          if (remap) {
+            spinner.stop();
+            console.log(chalk.gray(`  Remapping project path: ${remap.oldHomeKey} → ${remap.newHomeKey}`));
+            spinner.start();
+            // Rename the directory in staging so it restores to the right place
+            const oldDir = path.join(backupDir, 'projects', remap.oldHomeKey);
+            const newDir = path.join(backupDir, 'projects', remap.newHomeKey);
+            if (await fs.pathExists(oldDir) && !(await fs.pathExists(newDir))) {
+              await fs.move(oldDir, newDir);
+            }
+          }
+        }
 
         if (adapter.customExtract) {
           const files = await fs.readdir(backupDir);
           for (const file of files) {
-            const dest = path.join(adapter.source, file);
-            if (await fs.pathExists(dest)) {
-              changes.skipped.push(dest);
+            const destFile = path.join(adapter.source, file);
+            if (await fs.pathExists(destFile)) {
+              const srcStat = await fs.stat(path.join(backupDir, file));
+              const destStat = await fs.stat(destFile);
+              if (srcStat.mtimeMs > destStat.mtimeMs) {
+                await fs.copy(path.join(backupDir, file), destFile);
+                changes.updated.push(destFile);
+              } else {
+                changes.skipped.push(destFile);
+              }
             } else {
-              await fs.copy(path.join(backupDir, file), dest);
-              changes.added.push(dest);
+              await fs.copy(path.join(backupDir, file), destFile);
+              changes.added.push(destFile);
             }
           }
         } else {
-          spinner.text = `Restoring ${chalk.cyan(adapter.name)} memory to ${adapter.source}...`;
+          spinner.text = `Restoring ${chalk.cyan(adapter.name)} to ${adapter.source}...`;
           await fs.ensureDir(adapter.source);
-          await copyMissing(backupDir, adapter.source, changes);
+          await syncFiles(backupDir, adapter.source, changes);
         }
 
         // Show summary of changes
         spinner.stop();
-        if (changes.added.length > 0) {
-          console.log(chalk.green.bold(`\n  ✔ ${adapter.name} — ${changes.added.length} file(s) added:`));
+        const totalChanged = changes.added.length + changes.updated.length;
+        if (totalChanged > 0) {
+          console.log(chalk.green.bold(`\n  ${adapter.icon} ${adapter.name} — ${totalChanged} file(s) restored to ${chalk.underline(adapter.source)}`));
           for (const f of changes.added) {
-            console.log(chalk.green(`    + ${f}`));
+            console.log(chalk.green(`    + ${path.basename(f)}`) + chalk.gray(` (new)`));
+          }
+          for (const f of changes.updated) {
+            console.log(chalk.yellow(`    ↻ ${path.basename(f)}`) + chalk.gray(` (updated)`));
           }
         }
         if (changes.skipped.length > 0) {
-          console.log(chalk.gray(`  ⏭ ${changes.skipped.length} file(s) already existed (kept yours)`));
+          console.log(chalk.gray(`  ⏭ ${changes.skipped.length} file(s) already up to date`));
         }
-        if (changes.added.length === 0 && changes.skipped.length > 0) {
-          console.log(chalk.gray(`  Nothing new to add — you're already up to date.`));
+        if (totalChanged === 0) {
+          console.log(chalk.gray(`  ✔ ${adapter.name} — already up to date`));
         }
         spinner.start();
 
+        allResults.push({ name: adapter.name, icon: adapter.icon, dest: adapter.source, added: changes.added.length, updated: changes.updated.length });
         restoredAny = true;
       } else {
-        spinner.info(chalk.gray(`Skipped restoring ${adapter.name}.`));
+        spinner.info(chalk.gray(`Skipped ${adapter.name}.`));
         spinner.start();
       }
     }
   }
 
+  // Final recap
+  if (allResults.length > 0) {
+    spinner.stop();
+    console.log('\n' + chalk.gray('─'.repeat(40)));
+    console.log(chalk.bold.white('\n  Restore Summary:\n'));
+    for (const r of allResults) {
+      const count = r.added + r.updated;
+      console.log(`  ${r.icon} ${chalk.white(r.name)}`);
+      console.log(chalk.gray(`     ${count} file(s) → ${r.dest}`));
+    }
+    console.log('');
+  }
+
   return restoredAny;
 }

package/src/commands/init.js

@@ -67,38 +67,23 @@ export async function initCommand() {
     }]);
     config.localPath = localPath;
   } else {
-    // Pre-fill username if detected, just ask for repo name
-    const prompts = [];
-
-    if (detectedUser) {
-      console.log(chalk.gray(`  GitHub user: ${chalk.cyan(detectedUser)}`));
-      prompts.push({
+    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 (${detectedUser}/???):`,
+        message: 'Repo name:',
         default: 'ai-memory',
         validate: (input) => input.trim() ? true : 'Required'
-      });
-    } else {
-      prompts.push(
-        {
-          type: 'input',
-          name: 'username',
-          message: 'GitHub username:',
-          validate: (input) => input.trim() ? true : 'Required'
-        },
-        {
-          type: 'input',
-          name: 'repo',
-          message: 'Repo name:',
-          default: 'ai-memory',
-          validate: (input) => input.trim() ? true : 'Required'
-        }
-      );
-    }
-
-    const answers = await inquirer.prompt(prompts);
-    const username = (answers.username || detectedUser).trim();
+      }
+    ]);
+    const username = answers.username.trim();
     const repo = answers.repo.trim();
 
     config.gitRepo = `https://github.com/${username}/${repo}.git`;

package/src/commands/push.js

@@ -68,12 +68,34 @@ export async function pushCommand() {
 
     spinner.stop();
 
+    // Count total files
+    let totalFiles = 0;
+    for (const adapter of adapters) {
+      const adapterDir = path.join(stagingDir, adapter.name.toLowerCase().replace(/ /g, '-'));
+      if (await fs.pathExists(adapterDir)) {
+        const countDir = async (dir) => {
+          let c = 0;
+          const entries = await fs.readdir(dir, { withFileTypes: true });
+          for (const e of entries) {
+            if (e.isDirectory()) c += await countDir(path.join(dir, e.name));
+            else c++;
+          }
+          return c;
+        };
+        totalFiles += await countDir(adapterDir);
+      }
+    }
+
+    const dest = config.provider === 'git' ? config.gitRepo : config.localPath;
+
     // Success output
     const toolList = found.map(t => chalk.cyan('  ✔ ' + t)).join('\n');
     console.log('\n' + boxen(
       gradient.pastel('  Backed up!  ') + '\n\n' +
       toolList + '\n\n' +
-      chalk.gray(`${found.length} tool${found.length !== 1 ? 's' : ''} synced to ${config.provider === 'git' ? 'GitHub' : 'local storage'}`),
+      chalk.white(`${totalFiles} files from ${found.length} tool${found.length !== 1 ? 's' : ''}`) + '\n' +
+      chalk.gray(`→ ${dest}`) + '\n\n' +
+      chalk.gray('Restore on another machine with: ') + chalk.cyan('memoir restore'),
       { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
     ) + '\n');
   } catch (error) {

package/src/commands/restore.js

@@ -41,16 +41,20 @@ export async function restoreCommand() {
     spinner.stop();
 
     if (restored) {
-      console.log('\n' + boxen(
-        gradient.pastel('  Restored!  ') + '\n\n' +
+      console.log(boxen(
+        gradient.pastel('  Done!  ') + '\n\n' +
         chalk.white('Your AI tools have their memories back.') + '\n' +
-        chalk.gray('They remember everything.'),
+        chalk.gray('Restart your AI tools to pick up the changes.'),
         { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
       ) + '\n');
     } else {
       console.log('\n' + boxen(
-        chalk.yellow('No memories were restored.\n\n') +
-        chalk.gray('Run ') + chalk.cyan('memoir push') + chalk.gray(' on another machine first.'),
+        chalk.yellow('Nothing was restored.\n\n') +
+        chalk.white('This can happen if:\n') +
+        chalk.gray('  1. You haven\'t run ') + chalk.cyan('memoir push') + chalk.gray(' on another machine yet\n') +
+        chalk.gray('  2. You skipped all the restore prompts\n') +
+        chalk.gray('  3. The backup repo is empty\n\n') +
+        chalk.gray('Try: ') + chalk.cyan('memoir view') + chalk.gray(' to see what\'s in your backup'),
         { padding: 1, borderStyle: 'round', borderColor: 'yellow' }
       ) + '\n');
     }