memoir-cli 3.1.0 → 3.2.0

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();
 });

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "memoir-cli",
-  "version": "3.1.0",
+  "version": "3.2.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",
   "bin": {
-    "memoir": "bin/memoir.js"
+    "memoir": "bin/memoir.js",
+    "memoir-mcp": "src/mcp.js"
   },
   "repository": {
     "type": "git",
@@ -52,17 +53,21 @@
     "context-sync",
     "session-handoff",
     "snapshot",
-    "resume"
+    "resume",
+    "mcp",
+    "mcp-server",
+    "model-context-protocol"
   ],
   "author": "camgitt",
   "license": "MIT",
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.28.0",
     "boxen": "^7.1.1",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "fs-extra": "^11.2.0",
     "gradient-string": "^3.0.0",
     "inquirer": "^9.2.15",
-"ora": "^7.0.1"
+    "ora": "^7.0.1"
   }
 }

package/src/commands/projects.js

@@ -0,0 +1,240 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { execFileSync } from 'child_process';
+
+const home = os.homedir();
+const TODOS_PATH = path.join(home, '.config', 'memoir', 'project-todos.json');
+
+// ─── Helpers ───
+
+async function loadTodos() {
+  try {
+    return await fs.readJson(TODOS_PATH);
+  } catch {
+    return {};
+  }
+}
+
+async function saveTodos(todos) {
+  await fs.ensureDir(path.dirname(TODOS_PATH));
+  await fs.writeJson(TODOS_PATH, todos, { spaces: 2 });
+}
+
+function git(args, cwd) {
+  try {
+    return execFileSync('git', args, {
+      cwd,
+      stdio: ['pipe', 'pipe', 'ignore'],
+      timeout: 5000,
+    }).toString().trim();
+  } catch {
+    return null;
+  }
+}
+
+function timeAgo(dateStr) {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const mins = Math.floor(diff / 60000);
+  if (mins < 60) return `${mins}m ago`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return `${hrs}h ago`;
+  const days = Math.floor(hrs / 24);
+  if (days < 30) return `${days}d ago`;
+  return `${Math.floor(days / 30)}mo ago`;
+}
+
+// ─── Scan ───
+
+async function discoverProjects() {
+  const maxDepth = 3;
+  const skipDirs = new Set([
+    'node_modules', '.git', '.next', '.vercel', 'dist', 'build',
+    '__pycache__', '.venv', 'venv', '.cache', '.npm', '.bun',
+    'Library', '.Trash', 'Applications', 'Pictures', 'Music',
+    'Movies', 'Public', 'Downloads', '.local', '.cargo', '.rustup',
+    '.docker', '.ssh', '.config', '.claude', '.gemini',
+  ]);
+
+  const projectMarkers = [
+    'package.json', 'Cargo.toml', 'go.mod', 'pyproject.toml',
+    'requirements.txt', 'Gemfile', 'pom.xml', 'build.gradle',
+    'Makefile', 'CMakeLists.txt', '.project', 'CLAUDE.md',
+    'GEMINI.md', 'AGENTS.md',
+    '.gitignore', 'index.html', 'main.py', 'app.py', 'index.js',
+  ];
+
+  const projects = [];
+
+  const scanDir = async (dir, depth = 0) => {
+    if (depth > maxDepth) return;
+    let entries;
+    try { entries = await fs.readdir(dir, { withFileTypes: true }); } catch { return; }
+
+    const hasMarker = entries.some(e => !e.isDirectory() && projectMarkers.includes(e.name));
+    if (hasMarker && dir !== home) {
+      projects.push(dir);
+      return;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.') && entry.name !== '.github') continue;
+      if (skipDirs.has(entry.name)) continue;
+      await scanDir(path.join(dir, entry.name), depth + 1);
+    }
+  };
+
+  await scanDir(home);
+  return projects;
+}
+
+function getProjectStatus(dir) {
+  const name = path.basename(dir);
+  const hasGit = fs.pathExistsSync(path.join(dir, '.git'));
+
+  const info = { name, path: dir, hasGit, branch: null, dirty: false, logs: [] };
+
+  if (!hasGit) return info;
+
+  info.branch = git(['branch', '--show-current'], dir) || 'unknown';
+
+  const status = git(['status', '--porcelain'], dir);
+  info.dirty = status ? status.length > 0 : false;
+
+  const logRaw = git(['log', '-5', '--format=%ad|%s', '--date=format:%b %d, %H:%M'], dir);
+  if (logRaw) {
+    info.logs = logRaw.split('\n').filter(Boolean).map(line => {
+      const sep = line.indexOf('|');
+      return { date: line.slice(0, sep), msg: line.slice(sep + 1) };
+    });
+  }
+
+  const lastDate = git(['log', '-1', '--format=%aI'], dir);
+  if (lastDate) info.lastActivity = lastDate;
+
+  return info;
+}
+
+// ─── Commands ───
+
+export async function projectsListCommand(options) {
+  const dirs = await discoverProjects();
+  const todos = await loadTodos();
+
+  // Gather status for all projects
+  const projects = dirs.map(d => {
+    const s = getProjectStatus(d);
+    s.todos = todos[s.name] || [];
+    return s;
+  });
+
+  // Sort by last activity (most recent first)
+  projects.sort((a, b) => {
+    if (!a.lastActivity && !b.lastActivity) return 0;
+    if (!a.lastActivity) return 1;
+    if (!b.lastActivity) return -1;
+    return new Date(b.lastActivity) - new Date(a.lastActivity);
+  });
+
+  if (options.json) {
+    console.log(JSON.stringify(projects, null, 2));
+    return;
+  }
+
+  console.log('\n' + boxen(
+    chalk.white.bold('  projects  ') + chalk.gray(`  ${projects.length} found`),
+    { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
+  ));
+
+  const limit = options.all ? projects.length : Math.min(projects.length, 15);
+
+  for (let i = 0; i < limit; i++) {
+    const p = projects[i];
+    const dot = p.hasGit
+      ? (p.dirty ? chalk.yellow('●') : chalk.green('●'))
+      : chalk.gray('●');
+
+    const age = p.lastActivity ? chalk.gray(` ${timeAgo(p.lastActivity)}`) : '';
+    const branchTag = p.branch && p.branch !== 'main' && p.branch !== 'master'
+      ? chalk.magenta(` [${p.branch}]`)
+      : '';
+    const dirtyTag = p.dirty ? chalk.yellow(' *') : '';
+    const todoTag = p.todos.length > 0
+      ? chalk.yellow(` (${p.todos.length} todo${p.todos.length > 1 ? 's' : ''})`)
+      : '';
+
+    console.log(`\n  ${dot} ${chalk.white.bold(p.name)}${branchTag}${dirtyTag}${todoTag}${age}`);
+
+    // Show last few commits
+    const logCount = options.verbose ? 5 : 2;
+    for (let j = 0; j < Math.min(p.logs.length, logCount); j++) {
+      const log = p.logs[j];
+      console.log(`    ${chalk.gray(log.date)} ${chalk.dim(log.msg)}`);
+    }
+
+    // Show todos inline
+    if (p.todos.length > 0 && options.verbose) {
+      for (const t of p.todos) {
+        console.log(`    ${chalk.yellow('□')} ${chalk.yellow(t)}`);
+      }
+    }
+  }
+
+  if (!options.all && projects.length > 15) {
+    console.log(chalk.gray(`\n  ... and ${projects.length - 15} more (use --all to show all)`));
+  }
+
+  console.log(chalk.gray(`\n  ${chalk.green('●')} clean  ${chalk.yellow('●')} dirty  ${chalk.gray('●')} no git\n`));
+}
+
+export async function projectsTodoCommand(projectName, text, options) {
+  const todos = await loadTodos();
+
+  // List todos for a project
+  if (!text && !options.done && !options.clear) {
+    const items = todos[projectName] || [];
+    if (items.length === 0) {
+      console.log(chalk.gray(`\n  No todos for ${projectName}\n`));
+      return;
+    }
+    console.log(chalk.white.bold(`\n  ${projectName} todos:\n`));
+    items.forEach((t, i) => {
+      console.log(`  ${chalk.gray(`${i + 1}.`)} ${chalk.yellow('□')} ${t}`);
+    });
+    console.log('');
+    return;
+  }
+
+  // Mark done
+  if (options.done !== undefined) {
+    const idx = parseInt(options.done, 10) - 1;
+    const items = todos[projectName] || [];
+    if (idx < 0 || idx >= items.length) {
+      console.error(chalk.red(`\n  ✖ Invalid index. ${projectName} has ${items.length} todo(s).\n`));
+      return;
+    }
+    const removed = items.splice(idx, 1)[0];
+    todos[projectName] = items;
+    if (items.length === 0) delete todos[projectName];
+    await saveTodos(todos);
+    console.log(chalk.green(`\n  ✔ Done: ${removed}\n`));
+    return;
+  }
+
+  // Clear all
+  if (options.clear) {
+    delete todos[projectName];
+    await saveTodos(todos);
+    console.log(chalk.green(`\n  ✔ Cleared all todos for ${projectName}\n`));
+    return;
+  }
+
+  // Add todo
+  if (!todos[projectName]) todos[projectName] = [];
+  todos[projectName].push(text);
+  await saveTodos(todos);
+  console.log(chalk.green(`\n  ✔ Added to ${projectName}: ${text}\n`));
+}

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);
@@ -170,14 +179,16 @@ export async function pushCommand(options = {}) {
         mask: '*',
         validate: (input) => input.length >= 6 ? true : 'Passphrase must be at least 6 characters'
       }]);
-      spinner.start(chalk.gray('Encrypting...'));
+      spinner.start(chalk.gray('Deriving encryption key...'));
 
       encryptedDir = path.join(os.tmpdir(), `memoir-encrypted-${Date.now()}`);
       await fs.ensureDir(encryptedDir);
-      await encryptDirectory(stagingDir, encryptedDir, passphrase);
+      const encryptedCount = await encryptDirectory(stagingDir, encryptedDir, passphrase, spinner);
+      spinner.succeed(chalk.green(spinner.text));
+      spinner.start();
 
       // Save verify token so restore can check passphrase before decrypting
-      const token = createVerifyToken(passphrase);
+      const token = await createVerifyToken(passphrase);
       await fs.writeFile(path.join(encryptedDir, 'verify.enc'), token);
 
       uploadDir = encryptedDir;
@@ -226,6 +237,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';
       }