memoir-cli 1.5.2 → 2.0.1

package/src/commands/diff.js

@@ -0,0 +1,221 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import ora from 'ora';
+import boxen from 'boxen';
+import { execSync } from 'child_process';
+import { getConfig } from '../config.js';
+import { adapters } from '../adapters/index.js';
+
+async function listFiles(dir, prefix = '') {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name === '.git') continue;
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...await listFiles(path.join(dir, entry.name), rel));
+    } else {
+      files.push({ path: rel });
+    }
+  }
+  return files;
+}
+
+function isBinaryFile(filePath) {
+  const binaryExts = ['.png', '.jpg', '.jpeg', '.gif', '.ico', '.woff', '.woff2', '.ttf', '.eot', '.zip', '.tar', '.gz', '.db', '.sqlite'];
+  return binaryExts.includes(path.extname(filePath).toLowerCase());
+}
+
+function simpleDiff(oldText, newText) {
+  const oldLines = oldText.split('\n');
+  const newLines = newText.split('\n');
+  const output = [];
+
+  const oldSet = new Set(oldLines);
+  const newSet = new Set(newLines);
+
+  for (const line of oldLines) {
+    if (!newSet.has(line) && line.trim()) {
+      output.push(chalk.red(`  - ${line}`));
+    }
+  }
+  for (const line of newLines) {
+    if (!oldSet.has(line) && line.trim()) {
+      output.push(chalk.green(`  + ${line}`));
+    }
+  }
+
+  return output;
+}
+
+export async function diffCommand() {
+  const config = await getConfig();
+  if (!config) {
+    console.log(chalk.red('\n✖ Not configured yet. Run: memoir init\n'));
+    return;
+  }
+
+  const spinner = ora('Comparing local files against last backup...').start();
+  const stagingDir = path.join(os.tmpdir(), `memoir-diff-${Date.now()}`);
+  await fs.ensureDir(stagingDir);
+
+  try {
+    if (config.provider === 'git') {
+      execSync(`git clone --depth 1 ${config.gitRepo} .`, { cwd: stagingDir, stdio: 'ignore' });
+    } else {
+      const resolvedSource = config.localPath.replace(/^~/, os.homedir());
+      if (!(await fs.pathExists(resolvedSource))) {
+        spinner.fail('No backup found. Run: memoir push');
+        return;
+      }
+      await fs.copy(resolvedSource, stagingDir);
+    }
+
+    spinner.stop();
+
+    const summary = { added: [], modified: [], deleted: [], unchanged: 0 };
+    const details = [];
+
+    for (const adapter of adapters) {
+      const backupDir = path.join(stagingDir, adapter.name.toLowerCase().replace(/ /g, '-'));
+      const backupExists = await fs.pathExists(backupDir);
+
+      // Get local files for this adapter
+      const localFiles = new Set();
+      if (adapter.customExtract) {
+        for (const file of adapter.files) {
+          if (await fs.pathExists(path.join(adapter.source, file))) {
+            localFiles.add(file);
+          }
+        }
+      } else if (await fs.pathExists(adapter.source)) {
+        // Walk local source with the adapter's filter
+        const walk = async (dir, prefix = '') => {
+          const entries = await fs.readdir(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (adapter.filter && !adapter.filter(fullPath)) continue;
+            if (entry.isDirectory()) {
+              await walk(fullPath, rel);
+            } else {
+              localFiles.add(rel);
+            }
+          }
+        };
+        await walk(adapter.source);
+      }
+
+      // Get backup files
+      const backupFiles = new Set();
+      if (backupExists) {
+        const files = await listFiles(backupDir);
+        files.forEach(f => backupFiles.add(f.path));
+      }
+
+      // New files (local but not in backup)
+      for (const file of localFiles) {
+        if (!backupFiles.has(file)) {
+          if (!isBinaryFile(file)) {
+            summary.added.push({ tool: adapter.name, icon: adapter.icon, file });
+          }
+        }
+      }
+
+      // Deleted files (in backup but not local)
+      for (const file of backupFiles) {
+        if (!localFiles.has(file)) {
+          summary.deleted.push({ tool: adapter.name, icon: adapter.icon, file });
+        }
+      }
+
+      // Modified files (in both, content differs)
+      for (const file of localFiles) {
+        if (backupFiles.has(file) && !isBinaryFile(file)) {
+          const localPath = adapter.customExtract
+            ? path.join(adapter.source, file)
+            : path.join(adapter.source, file);
+          const backupPath = path.join(backupDir, file);
+
+          try {
+            const localContent = await fs.readFile(localPath, 'utf8');
+            const backupContent = await fs.readFile(backupPath, 'utf8');
+
+            if (localContent !== backupContent) {
+              const diffLines = simpleDiff(backupContent, localContent);
+              summary.modified.push({ tool: adapter.name, icon: adapter.icon, file });
+              details.push({ tool: adapter.name, icon: adapter.icon, file, lines: diffLines });
+            } else {
+              summary.unchanged++;
+            }
+          } catch {
+            summary.unchanged++;
+          }
+        }
+      }
+    }
+
+    // Print summary
+    const totalChanges = summary.added.length + summary.modified.length + summary.deleted.length;
+
+    if (totalChanges === 0) {
+      console.log('\n' + boxen(
+        chalk.green('Everything is in sync.') + '\n' +
+        chalk.gray(`${summary.unchanged} files unchanged since last backup.`),
+        { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
+      ) + '\n');
+      return;
+    }
+
+    console.log('\n' + boxen(
+      chalk.cyan.bold('Changes since last backup'),
+      { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'cyan' }
+    ));
+
+    if (summary.added.length > 0) {
+      console.log(chalk.green.bold(`\n  + ${summary.added.length} new file(s)`));
+      for (const f of summary.added) {
+        console.log(chalk.green(`    ${f.icon} ${f.tool}/${f.file}`));
+      }
+    }
+
+    if (summary.modified.length > 0) {
+      console.log(chalk.yellow.bold(`\n  ~ ${summary.modified.length} modified file(s)`));
+      for (const f of summary.modified) {
+        console.log(chalk.yellow(`    ${f.icon} ${f.tool}/${f.file}`));
+      }
+    }
+
+    if (summary.deleted.length > 0) {
+      console.log(chalk.red.bold(`\n  - ${summary.deleted.length} removed file(s)`));
+      for (const f of summary.deleted) {
+        console.log(chalk.red(`    ${f.icon} ${f.tool}/${f.file}`));
+      }
+    }
+
+    if (summary.unchanged > 0) {
+      console.log(chalk.gray(`\n  ${summary.unchanged} file(s) unchanged`));
+    }
+
+    // Show diffs for modified files
+    if (details.length > 0) {
+      console.log(chalk.gray('\n' + '─'.repeat(40)));
+      console.log(chalk.bold.white('\n  Changes:\n'));
+
+      for (const d of details) {
+        console.log(`  ${d.icon} ${chalk.cyan(d.tool + '/' + d.file)}`);
+        for (const line of d.lines) {
+          console.log(line);
+        }
+        console.log('');
+      }
+    }
+
+    console.log(chalk.gray('  Run ') + chalk.cyan('memoir push') + chalk.gray(' to back up these changes.\n'));
+
+  } finally {
+    await fs.remove(stagingDir);
+  }
+}

package/src/commands/restore.js

@@ -31,10 +31,12 @@ export async function restoreCommand(options = {}) {
 
     const onlyFilter = options.only ? options.only.split(',').map(t => t.trim().toLowerCase()) : null;
 
+    const autoYes = options.yes || false;
+
     if (config.provider === 'local' || config.provider.includes('local')) {
-      restored = await fetchFromLocal(config, stagingDir, spinner, onlyFilter);
+      restored = await fetchFromLocal(config, stagingDir, spinner, onlyFilter, autoYes);
     } else if (config.provider === 'git' || config.provider.includes('git')) {
-      restored = await fetchFromGit(config, stagingDir, spinner, onlyFilter);
+      restored = await fetchFromGit(config, stagingDir, spinner, onlyFilter, autoYes);
     } else {
       spinner.fail(chalk.red(`Unknown provider: ${config.provider}`));
       return;

package/src/commands/resume.js

@@ -0,0 +1,166 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import ora from 'ora';
+import boxen from 'boxen';
+import gradient from 'gradient-string';
+import { getConfig } from '../config.js';
+import { execFileSync } from 'child_process';
+
+const home = os.homedir();
+
+// Fetch latest handoff from git backup
+async function fetchLatestHandoff(config, spinner) {
+  const tmpDir = path.join(os.tmpdir(), `memoir-resume-${Date.now()}`);
+  await fs.ensureDir(tmpDir);
+
+  try {
+    if (config.provider === 'git' || config.provider.includes('git')) {
+      spinner.text = chalk.gray('Pulling latest handoff from GitHub...');
+      execFileSync('git', ['clone', '--depth', '1', config.gitRepo, '.'], { cwd: tmpDir, stdio: 'ignore' });
+    } else if (config.provider === 'local' || config.provider.includes('local')) {
+      const resolvedSource = config.localPath.replace(/^~/, home);
+      spinner.text = chalk.gray('Fetching handoff from local backup...');
+      await fs.copy(resolvedSource, tmpDir);
+    }
+
+    const handoffDir = path.join(tmpDir, 'handoffs');
+    if (!await fs.pathExists(handoffDir)) {
+      return null;
+    }
+
+    // Find the newest handoff file
+    const files = (await fs.readdir(handoffDir))
+      .filter(f => f.endsWith('.md') && f !== 'latest.md')
+      .sort()
+      .reverse();
+
+    if (files.length === 0) return null;
+
+    const content = await fs.readFile(path.join(handoffDir, files[0]), 'utf8');
+    return { filename: files[0], content };
+  } finally {
+    await fs.remove(tmpDir);
+  }
+}
+
+// Inject handoff into a tool's context location
+async function injectHandoff(content, tool) {
+  const targets = {
+    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, '');
+      const memDir = path.join(home, '.claude', 'projects', cwdKey, 'memory');
+      return path.join(memDir, 'handoff.md');
+    },
+    gemini: () => {
+      return path.join(process.cwd(), 'GEMINI.md');
+    },
+    cursor: () => {
+      return path.join(process.cwd(), '.cursor', 'rules', 'handoff.mdc');
+    },
+    codex: () => {
+      return path.join(process.cwd(), 'AGENTS.md');
+    }
+  };
+
+  const getTarget = targets[tool];
+  if (!getTarget) {
+    throw new Error(`Unknown tool: ${tool}. Supported: claude, gemini, cursor, codex`);
+  }
+
+  const targetPath = getTarget();
+  await fs.ensureDir(path.dirname(targetPath));
+
+  if (tool === 'gemini' && await fs.pathExists(targetPath)) {
+    // Append to existing GEMINI.md
+    const existing = await fs.readFile(targetPath, 'utf8');
+    if (!existing.includes('# Session Handoff')) {
+      await fs.writeFile(targetPath, existing + '\n\n' + content);
+    } else {
+      // Replace existing handoff section
+      const before = existing.split('# Session Handoff')[0];
+      await fs.writeFile(targetPath, before + content);
+    }
+  } else {
+    await fs.writeFile(targetPath, content);
+  }
+
+  return targetPath;
+}
+
+export async function resumeCommand(options = {}) {
+  const config = await getConfig();
+
+  if (!config) {
+    console.log('\n' + boxen(
+      chalk.red('Not configured yet\n\n') +
+      chalk.white('Run ') + chalk.cyan.bold('memoir init') + chalk.white(' to get started.'),
+      { padding: 1, borderStyle: 'round', borderColor: 'red' }
+    ) + '\n');
+    return;
+  }
+
+  console.log();
+  const spinner = ora({ text: chalk.gray('Fetching latest handoff...'), spinner: 'dots' }).start();
+
+  // First check local cache
+  const localLatest = path.join(home, '.config', 'memoir', 'handoffs', 'latest.md');
+  let handoff;
+
+  // Try remote first
+  try {
+    handoff = await fetchLatestHandoff(config, spinner);
+  } catch (err) {
+    spinner.warn(chalk.yellow(`Remote fetch failed: ${err.message}`));
+    spinner.start();
+  }
+
+  // Fallback to local cache
+  if (!handoff && await fs.pathExists(localLatest)) {
+    handoff = { filename: 'latest.md', content: await fs.readFile(localLatest, 'utf8') };
+  }
+
+  if (!handoff) {
+    spinner.fail(chalk.red('No handoffs found.'));
+    console.log(chalk.gray('\n  Run ') + chalk.cyan('memoir snapshot') + chalk.gray(' on another machine first.\n'));
+    return;
+  }
+
+  // Save locally
+  const localHandoffDir = path.join(home, '.config', 'memoir', 'handoffs');
+  await fs.ensureDir(localHandoffDir);
+  await fs.writeFile(path.join(localHandoffDir, 'latest.md'), handoff.content);
+
+  spinner.stop();
+
+  // Display the handoff
+  console.log(boxen(
+    gradient.pastel('  Session Handoff  ') + '\n\n' +
+    handoff.content
+      .replace(/^---[\s\S]*?---\n/, '') // Strip YAML frontmatter for display
+      .trim(),
+    { padding: 1, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
+  ));
+
+  // Inject if requested
+  if (options.inject) {
+    const tool = options.to || 'claude';
+    spinner.start(chalk.gray(`Injecting handoff for ${tool}...`));
+    try {
+      const targetPath = await injectHandoff(handoff.content, tool);
+      spinner.stop();
+      console.log('\n' + chalk.green(`  Injected handoff → ${targetPath}`));
+      console.log(chalk.gray(`  ${tool.charAt(0).toUpperCase() + tool.slice(1)} will read this on next session.\n`));
+    } catch (err) {
+      spinner.fail(chalk.red(`Inject failed: ${err.message}`));
+    }
+  } else {
+    console.log('\n' + chalk.gray('  To inject into your AI tool:'));
+    console.log(chalk.cyan('    memoir resume --inject') + chalk.gray(' (Claude)'));
+    console.log(chalk.cyan('    memoir resume --inject --to gemini'));
+    console.log(chalk.cyan('    memoir resume --inject --to cursor') + '\n');
+  }
+}