memoir-cli 3.1.1 → 3.2.1

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "memoir-cli",
-  "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.",
+  "version": "3.2.1",
+  "mcpName": "io.github.camgitt/memoir",
+  "description": "Persistent memory for AI coding tools via MCP. Your AI remembers across sessions, tools, and machines. Works with Claude, Cursor, Gemini, Windsurf, and 7 more tools.",
   "main": "src/index.js",
   "type": "module",
   "bin": {
-    "memoir": "bin/memoir.js"
+    "memoir": "bin/memoir.js",
+    "memoir-mcp": "src/mcp.js"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/camgitt/memoir.git"
   },
-  "homepage": "https://github.com/camgitt/memoir#readme",
+  "homepage": "https://memoir.sh",
   "bugs": {
     "url": "https://github.com/camgitt/memoir/issues"
   },
@@ -20,49 +22,52 @@
     "test": "bash test-local.sh"
   },
   "keywords": [
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "ai-memory",
+    "persistent-memory",
     "ai",
     "cli",
-    "sync",
-    "memory",
-    "backup",
-    "restore",
-    "migrate",
-    "translate",
     "claude",
+    "claude-code",
+    "cursor",
+    "windsurf",
     "gemini",
+    "gemini-cli",
     "codex",
-    "cursor",
     "copilot",
-    "windsurf",
+    "chatgpt",
+    "openai",
     "aider",
     "zed",
     "cline",
     "continue-dev",
-    "profiles",
-    "ai-memory",
     "ai-tools",
-    "dotfiles",
-    "developer-tools",
-    "claude-code",
-    "gemini-cli",
-    "openai",
-    "chatgpt",
     "ai-assistant",
     "coding-assistant",
+    "developer-tools",
     "context-sync",
+    "memory-layer",
+    "cross-tool",
+    "sync",
+    "backup",
+    "restore",
+    "migrate",
     "session-handoff",
-    "snapshot",
-    "resume"
+    "dotfiles",
+    "profiles"
   ],
   "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/server.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.camgitt/memoir",
+  "description": "Persistent memory for AI coding tools via MCP. Remembers across sessions and machines.",
+  "repository": {
+    "url": "https://github.com/camgitt/memoir",
+    "source": "github"
+  },
+  "version": "3.2.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "memoir-cli",
+      "version": "3.2.0",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}

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

@@ -179,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;

package/src/commands/restore.js

@@ -11,10 +11,18 @@ import { fetchFromLocal, fetchFromGit } from '../providers/restore.js';
 import { decryptDirectory, verifyPassphrase } from '../security/encryption.js';
 import { detectLocalHomeKey } from '../adapters/restore.js';
 import { restoreWorkspace } from '../workspace/tracker.js';
+import { getSession } from '../cloud/auth.js';
+import { unbundleToDir } from '../cloud/storage.js';
+import { SUPABASE_URL, SUPABASE_ANON_KEY, STORAGE_BUCKET } from '../cloud/constants.js';
 
 const home = os.homedir();
 
 export async function restoreCommand(options = {}) {
+  // Handle --from <token> for shared links
+  if (options.from) {
+    return restoreFromShare(options);
+  }
+
   const config = await getConfig(options.profile);
 
   if (!config) {
@@ -37,7 +45,7 @@ export async function restoreCommand(options = {}) {
 
     const onlyFilter = options.only ? options.only.split(',').map(t => t.trim().toLowerCase()) : null;
 
-    const autoYes = options.yes || false;
+    const autoYes = !options.interactive;
 
     if (config.provider === 'local' || config.provider.includes('local')) {
       restored = await fetchFromLocal(config, stagingDir, spinner, onlyFilter, autoYes);
@@ -68,7 +76,7 @@ export async function restoreCommand(options = {}) {
 
         if (await fs.pathExists(verifyPath)) {
           const token = await fs.readFile(verifyPath);
-          if (!verifyPassphrase(token, passphrase)) {
+          if (!(await verifyPassphrase(token, passphrase))) {
             console.log(chalk.red('  Wrong passphrase. Try again.'));
             passphrase = null;
             continue;
@@ -85,7 +93,7 @@ export async function restoreCommand(options = {}) {
       spinner.start(chalk.gray('Decrypting...'));
       const decryptedDir = path.join(os.tmpdir(), `memoir-decrypted-${Date.now()}`);
       try {
-        const count = await decryptDirectory(stagingDir, decryptedDir, passphrase);
+        const count = await decryptDirectory(stagingDir, decryptedDir, passphrase, spinner);
         spinner.succeed(chalk.green(`Decrypted ${count} files`));
 
         // Now restore from decrypted dir
@@ -244,3 +252,189 @@ export async function restoreCommand(options = {}) {
     await fs.remove(stagingDir);
   }
 }
+
+async function restoreFromShare(options) {
+  const shareToken = options.from;
+
+  console.log();
+  const spinner = ora({ text: chalk.gray('Fetching share link...'), spinner: 'dots' }).start();
+
+  const stagingDir = path.join(os.tmpdir(), `memoir-share-restore-${Date.now()}`);
+  await fs.ensureDir(stagingDir);
+
+  try {
+    // Fetch share metadata from Supabase
+    const metaRes = await fetch(
+      `${SUPABASE_URL}/rest/v1/shared_links?select=*&token=eq.${shareToken}&limit=1`,
+      {
+        headers: {
+          'apikey': SUPABASE_ANON_KEY,
+          'Content-Type': 'application/json',
+        },
+      }
+    );
+
+    if (!metaRes.ok) {
+      throw new Error('Failed to fetch share link');
+    }
+
+    const links = await metaRes.json();
+    if (!links || links.length === 0) {
+      spinner.stop();
+      console.log('\n' + boxen(
+        chalk.red('✖ Share link not found\n\n') +
+        chalk.gray('The link may have expired or been deleted.'),
+        { padding: 1, borderStyle: 'round', borderColor: 'red' }
+      ) + '\n');
+      return;
+    }
+
+    const shareLink = links[0];
+
+    // Check expiry
+    if (new Date(shareLink.expires_at) < new Date()) {
+      spinner.stop();
+      console.log('\n' + boxen(
+        chalk.red('✖ Share link expired\n\n') +
+        chalk.gray(`This link expired on ${new Date(shareLink.expires_at).toLocaleString()}`),
+        { padding: 1, borderStyle: 'round', borderColor: 'red' }
+      ) + '\n');
+      return;
+    }
+
+    // Check use count
+    if (shareLink.use_count >= shareLink.max_uses) {
+      spinner.stop();
+      console.log('\n' + boxen(
+        chalk.red('✖ Share link exhausted\n\n') +
+        chalk.gray(`This link has been used ${shareLink.use_count}/${shareLink.max_uses} times.`),
+        { padding: 1, borderStyle: 'round', borderColor: 'red' }
+      ) + '\n');
+      return;
+    }
+
+    // Show share info
+    spinner.stop();
+    const tools = shareLink.tools || [];
+    if (tools.length > 0) {
+      console.log(chalk.cyan('\n  Shared tools: ') + chalk.white(tools.join(', ')));
+    }
+    console.log(chalk.gray(`  Uses: ${shareLink.use_count + 1}/${shareLink.max_uses}`) +
+      chalk.gray(` | Expires: ${new Date(shareLink.expires_at).toLocaleString()}`));
+    console.log();
+
+    // Download the backup
+    spinner.start(chalk.gray('Downloading share bundle...'));
+
+    // Try authenticated first, fall back to anon key
+    const session = await getSession();
+    const authHeaders = session
+      ? { 'Authorization': `Bearer ${session.access_token}`, 'apikey': SUPABASE_ANON_KEY }
+      : { 'apikey': SUPABASE_ANON_KEY };
+
+    const dlRes = await fetch(`${SUPABASE_URL}/storage/v1/object/${STORAGE_BUCKET}/${shareLink.backup_id}`, {
+      headers: authHeaders,
+    });
+
+    if (!dlRes.ok) {
+      throw new Error(`Download failed: ${await dlRes.text()}`);
+    }
+
+    const gzipped = Buffer.from(await dlRes.arrayBuffer());
+    await unbundleToDir(gzipped, stagingDir);
+
+    // Decrypt — backup is always encrypted for shares
+    const manifestPath = path.join(stagingDir, 'manifest.enc');
+    if (!await fs.pathExists(manifestPath)) {
+      throw new Error('Share bundle is missing encryption manifest');
+    }
+
+    spinner.stop();
+    console.log(chalk.cyan('  🔒 This share is encrypted'));
+
+    // Verify passphrase
+    const verifyPath = path.join(stagingDir, 'verify.enc');
+    let passphrase;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      const { pass } = await inquirer.prompt([{
+        type: 'password',
+        name: 'pass',
+        message: 'Decryption passphrase:',
+        mask: '*',
+      }]);
+      passphrase = pass;
+
+      if (await fs.pathExists(verifyPath)) {
+        const token = await fs.readFile(verifyPath);
+        if (!(await verifyPassphrase(token, passphrase))) {
+          console.log(chalk.red('  Wrong passphrase. Try again.'));
+          passphrase = null;
+          continue;
+        }
+      }
+      break;
+    }
+
+    if (!passphrase) {
+      console.log(chalk.red('\n  Too many failed attempts.'));
+      return;
+    }
+
+    spinner.start(chalk.gray('Decrypting...'));
+    const decryptedDir = path.join(os.tmpdir(), `memoir-share-decrypted-${Date.now()}`);
+    let restored = false;
+
+    try {
+      const count = await decryptDirectory(stagingDir, decryptedDir, passphrase, spinner);
+      spinner.succeed(chalk.green(`Decrypted ${count} files`));
+
+      // Restore from decrypted dir
+      spinner.start(chalk.gray('Restoring...'));
+      const onlyFilter = options.only ? options.only.split(',').map(t => t.trim().toLowerCase()) : null;
+      const autoYes = !options.interactive;
+      const { restoreMemories } = await import('../adapters/restore.js');
+      restored = await restoreMemories(decryptedDir, spinner, onlyFilter, autoYes);
+    } catch (err) {
+      spinner.fail(chalk.red('Decryption failed: ') + err.message);
+      return;
+    } finally {
+      await fs.remove(decryptedDir);
+    }
+
+    // Increment use_count
+    try {
+      const patchHeaders = { 'apikey': SUPABASE_ANON_KEY, 'Content-Type': 'application/json' };
+      if (session) patchHeaders['Authorization'] = `Bearer ${session.access_token}`;
+
+      await fetch(`${SUPABASE_URL}/rest/v1/shared_links?token=eq.${shareToken}`, {
+        method: 'PATCH',
+        headers: patchHeaders,
+        body: JSON.stringify({ use_count: shareLink.use_count + 1 }),
+      });
+    } catch {
+      // Best-effort — don't fail restore if count update fails
+    }
+
+    spinner.stop();
+
+    if (restored) {
+      console.log('\n' + boxen(
+        gradient.pastel('  Done!  ') + '\n\n' +
+        chalk.white('Shared memories restored successfully.') + '\n' +
+        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('Nothing was restored.\n\n') +
+        chalk.gray('You may have skipped all the restore prompts.'),
+        { padding: 1, borderStyle: 'round', borderColor: 'yellow' }
+      ) + '\n');
+    }
+
+  } catch (error) {
+    spinner.fail(chalk.red('Restore from share failed: ') + error.message);
+  } finally {
+    await fs.remove(stagingDir);
+  }
+}