memoir-cli 1.2.1 → 1.4.0

package/bin/memoir.js

@@ -7,6 +7,7 @@ import { initCommand } from '../src/commands/init.js';
 import { pushCommand } from '../src/commands/push.js';
 import { restoreCommand } from '../src/commands/restore.js';
 import { statusCommand } from '../src/commands/status.js';
+import { viewCommand } from '../src/commands/view.js';
 
 const VERSION = '1.2.0';
 
@@ -72,6 +73,19 @@ program
     }
   });
 
+program
+  .command('view')
+  .alias('ls')
+  .description('Preview what files are in your backup')
+  .action(async () => {
+    try {
+      await viewCommand();
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
 program
   .command('migrate')
   .description('Translate memory between AI providers')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memoir-cli",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "Your AI remembers everything. Sync it everywhere.",
   "main": "src/index.js",
   "type": "module",

package/src/adapters/restore.js

@@ -5,6 +5,26 @@ import os from 'os';
 import inquirer from 'inquirer';
 import { adapters } from '../adapters/index.js';
 
+async function copyMissing(src, dest, changes) {
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      await fs.ensureDir(destPath);
+      await copyMissing(srcPath, destPath, changes);
+    } else {
+      if (await fs.pathExists(destPath)) {
+        changes.skipped.push(destPath);
+      } else {
+        await fs.copy(srcPath, destPath);
+        changes.added.push(destPath);
+      }
+    }
+  }
+}
+
 export async function restoreMemories(sourceDir, spinner) {
   let restoredAny = false;
 
@@ -14,12 +34,12 @@ 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.yellow(`⚠ Found backup for ${chalk.bold(adapter.name)}.`));
       const { confirm } = await inquirer.prompt([
         {
           type: 'confirm',
           name: 'confirm',
-          message: `Restore ${adapter.name} memory? This will overwrite existing configuration files!`,
+          message: `Restore ${adapter.name} memory? (only adds missing files, won't overwrite)`,
           default: false
         }
       ]);
@@ -27,18 +47,41 @@ export async function restoreMemories(sourceDir, spinner) {
       spinner.start();
 
       if (confirm) {
+        const changes = { added: [], skipped: [] };
+
         if (adapter.customExtract) {
-          // Restore individual files back to their original locations
           const files = await fs.readdir(backupDir);
           for (const file of files) {
             const dest = path.join(adapter.source, file);
-            await fs.copy(path.join(backupDir, file), dest, { overwrite: true });
+            if (await fs.pathExists(dest)) {
+              changes.skipped.push(dest);
+            } else {
+              await fs.copy(path.join(backupDir, file), dest);
+              changes.added.push(dest);
+            }
           }
         } else {
           spinner.text = `Restoring ${chalk.cyan(adapter.name)} memory to ${adapter.source}...`;
           await fs.ensureDir(adapter.source);
-          await fs.copy(backupDir, adapter.source, { overwrite: true });
+          await copyMissing(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:`));
+          for (const f of changes.added) {
+            console.log(chalk.green(`    + ${f}`));
+          }
+        }
+        if (changes.skipped.length > 0) {
+          console.log(chalk.gray(`  ⏭ ${changes.skipped.length} file(s) already existed (kept yours)`));
+        }
+        if (changes.added.length === 0 && changes.skipped.length > 0) {
+          console.log(chalk.gray(`  Nothing new to add — you're already up to date.`));
+        }
+        spinner.start();
+
         restoredAny = true;
       } else {
         spinner.info(chalk.gray(`Skipped restoring ${adapter.name}.`));

package/src/commands/init.js

@@ -4,78 +4,88 @@ import open from 'open';
 import boxen from 'boxen';
 import gradient from 'gradient-string';
 import { saveConfig } from '../config.js';
+import { pushCommand } from './push.js';
+import { restoreCommand } from './restore.js';
 
 export async function initCommand() {
   const title = gradient.pastel.multiline('memoir \\nYour AI Remembers Everything');
-  console.log('\\n' + boxen(title, { 
-    padding: 1, 
-    margin: 1, 
-    borderStyle: 'round', 
+  console.log('\\n' + boxen(title, {
+    padding: 1,
+    margin: 1,
+    borderStyle: 'round',
     borderColor: 'cyan',
     align: 'center'
   }));
 
-  console.log(chalk.gray("Let's configure where your AI knowledge will be safely stored.\\n"));
+  console.log(chalk.gray("Let's get your AI memory set up.\\n"));
 
-  const answers = await inquirer.prompt([
+  const { direction } = await inquirer.prompt([
     {
       type: 'list',
-      name: 'provider',
-      message: 'Choose your storage provider:',
+      name: 'direction',
+      message: 'What do you want to do?',
       choices: [
-        { name: '☁️  Git Repository ' + chalk.gray('(GitHub, GitLab - Best for syncing across computers)'), value: 'git' },
-        { name: '📂 Local Directory ' + chalk.gray('(Dropbox, iCloud - Best for local backups)'), value: 'local' }
+        { name: '⬆️  Upload ' + chalk.gray('(backup this machine\'s AI memory)'), value: 'upload' },
+        { name: '⬇️  Download ' + chalk.gray('(restore AI memory to this machine)'), value: 'download' }
       ]
-    },
-    {
-      type: 'input',
-      name: 'localPath',
-      message: 'Enter the full path to your sync directory ' + chalk.gray('(e.g., ~/Dropbox/memoir):'),
-      when: (answers) => answers.provider === 'local',
-      validate: (input) => input.trim() !== '' ? true : chalk.red('✖ Path is required')
-    },
+    }
+  ]);
+
+  const { provider } = await inquirer.prompt([
     {
-      type: 'confirm',
-      name: 'openBrowser',
-      message: 'Need to create an empty GitHub repository right now?',
-      when: (answers) => answers.provider === 'git',
-      default: false
+      type: 'list',
+      name: 'provider',
+      message: 'Where do you want to store it?',
+      choices: [
+        { name: '☁️  GitHub ' + chalk.gray('(sync across computers)'), value: 'git' },
+        { name: '📂 Local Directory ' + chalk.gray('(Dropbox, iCloud, etc.)'), value: 'local' }
+      ]
     }
   ]);
 
-  if (answers.openBrowser) {
-    console.log(chalk.cyan('\\n↗ Opening GitHub... Create an empty private repository, then return here.\\n'));
-    await open('https://github.com/new');
-  }
+  let config = { provider };
 
-  const finalAnswers = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'gitRepo',
-      message: 'Repository URL ' + chalk.gray('(e.g., git@github.com:username/ai-memory.git):'),
-      when: () => answers.provider === 'git',
-      validate: (input) => {
-        if (input.trim() === '') return chalk.red('✖ Repo URL is required');
-        if (!input.includes('github.com') && !input.includes('gitlab.com')) {
-          return chalk.yellow('⚠ Warning: This does not look like a standard GitHub/GitLab URL. Please verify.');
+  if (provider === 'local') {
+    const { localPath } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'localPath',
+        message: 'Path to sync directory ' + chalk.gray('(e.g., ~/Dropbox/memoir):'),
+        validate: (input) => input.trim() !== '' ? true : chalk.red('✖ Path is required')
+      }
+    ]);
+    config.localPath = localPath;
+  } else {
+    const { repoInput } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'repoInput',
+        message: 'GitHub repo ' + chalk.gray('(e.g., camgitt/brain):'),
+        validate: (input) => {
+          if (input.trim() === '') return chalk.red('✖ Repo is required');
+          return true;
         }
-        return true;
       }
-    }
-  ]);
+    ]);
 
-  const config = {
-    provider: answers.provider,
-    localPath: answers.localPath,
-    gitRepo: finalAnswers.gitRepo
-  };
+    // Accept shorthand like "camgitt/brain" or full URLs
+    let gitRepo = repoInput.trim();
+    if (!gitRepo.includes('github.com') && !gitRepo.includes('gitlab.com')) {
+      gitRepo = `https://github.com/${gitRepo}.git`;
+    }
+    config.gitRepo = gitRepo;
+  }
 
   await saveConfig(config);
 
-  console.log('\\n' + boxen(
-    chalk.green('✔ Configuration saved successfully!') + '\\n\\n' +
-    chalk.white('To backup your memory, run:') + '\\n' +
-    chalk.cyan.bold('memoir push'),
-    { padding: 1, borderStyle: 'single', borderColor: 'green' }
-  ) + '\\n');
+  console.log('\\n' + chalk.green('✔ Configuration saved!'));
+
+  // Immediately run the chosen action
+  if (direction === 'upload') {
+    console.log(chalk.cyan('\\n↗ Uploading your AI memory...\\n'));
+    await pushCommand();
+  } else {
+    console.log(chalk.cyan('\\n↙ Downloading your AI memory...\\n'));
+    await restoreCommand();
+  }
 }

package/src/commands/view.js

@@ -0,0 +1,176 @@
+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 inquirer from 'inquirer';
+import { execSync } from 'child_process';
+import { loadConfig } 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 {
+      const stat = await fs.stat(path.join(dir, entry.name));
+      files.push({ path: rel, size: stat.size });
+    }
+  }
+  return files;
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+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());
+}
+
+export async function viewCommand() {
+  const config = await loadConfig();
+  if (!config) {
+    console.log(chalk.red('\n✖ Not configured yet. Run: memoir init\n'));
+    return;
+  }
+
+  const spinner = ora('Fetching backup...').start();
+  const stagingDir = path.join(os.tmpdir(), `memoir-view-${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());
+      await fs.copy(resolvedSource, stagingDir);
+    }
+
+    spinner.stop();
+
+    console.log('\n' + boxen(
+      chalk.cyan.bold('Your Memoir Backup'),
+      { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'cyan' }
+    ));
+
+    let totalFiles = 0;
+    const viewableFiles = [];
+
+    for (const adapter of adapters) {
+      const adapterDir = path.join(stagingDir, adapter.name.toLowerCase().replace(/ /g, '-'));
+      if (await fs.pathExists(adapterDir)) {
+        const files = await listFiles(adapterDir);
+        totalFiles += files.length;
+
+        console.log('\n' + chalk.green.bold(`  ${adapter.name}`) + chalk.gray(` (${files.length} files)`));
+
+        for (const file of files) {
+          const localPath = path.join(adapter.source, file.path);
+          const backupPath = path.join(adapterDir, file.path);
+          const existsLocally = await fs.pathExists(localPath);
+
+          let status;
+          let diffType;
+          if (!existsLocally) {
+            status = chalk.yellow(' (new — not on this machine)');
+            diffType = 'new';
+          } else if (isBinaryFile(file.path)) {
+            status = chalk.gray(' (binary)');
+            diffType = 'binary';
+          } else {
+            // Compare content
+            const localContent = await fs.readFile(localPath, 'utf8');
+            const backupContent = await fs.readFile(backupPath, 'utf8');
+            if (localContent === backupContent) {
+              status = chalk.gray(' (identical)');
+              diffType = 'same';
+            } else {
+              status = chalk.cyan(' (different)');
+              diffType = 'different';
+            }
+          }
+
+          console.log(chalk.white(`    ${file.path}`) + chalk.gray(` ${formatSize(file.size)}`) + status);
+
+          if (diffType !== 'binary' && diffType !== 'same') {
+            viewableFiles.push({ file, adapter, adapterDir, localPath, diffType });
+          }
+        }
+      }
+    }
+
+    if (totalFiles === 0) {
+      console.log(chalk.yellow('\n  No backed up files found.\n'));
+      return;
+    }
+
+    console.log(chalk.gray(`\n  ${totalFiles} total files in backup\n`));
+
+    // Offer to view diffs
+    if (viewableFiles.length > 0) {
+      const { wantDiff } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'wantDiff',
+          message: 'View file contents/diffs?',
+          default: true
+        }
+      ]);
+
+      if (wantDiff) {
+        const choices = viewableFiles.map(vf => ({
+          name: `${vf.adapter.name}/${vf.file.path}` + (vf.diffType === 'new' ? chalk.yellow(' (new)') : chalk.cyan(' (different)')),
+          value: vf
+        }));
+
+        const { filesToView } = await inquirer.prompt([
+          {
+            type: 'checkbox',
+            name: 'filesToView',
+            message: 'Select files to view:',
+            choices
+          }
+        ]);
+
+        for (const vf of filesToView) {
+          const backupPath = path.join(vf.adapterDir, vf.file.path);
+          const backupContent = await fs.readFile(backupPath, 'utf8');
+
+          console.log('\n' + boxen(
+            chalk.cyan.bold(`${vf.adapter.name}/${vf.file.path}`),
+            { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'single', borderColor: 'cyan' }
+          ));
+
+          if (vf.diffType === 'new') {
+            console.log(chalk.yellow('\n  This file only exists in backup:\n'));
+            console.log(chalk.green(backupContent.split('\n').map(l => '  + ' + l).join('\n')));
+          } else {
+            // Show side by side: local vs backup
+            const localContent = await fs.readFile(vf.localPath, 'utf8');
+            const localLines = localContent.split('\n');
+            const backupLines = backupContent.split('\n');
+
+            console.log(chalk.gray('\n  ── Local (this machine) ──'));
+            console.log(localLines.map(l => '  ' + l).join('\n'));
+
+            console.log(chalk.cyan('\n  ── Backup (remote) ──'));
+            console.log(backupLines.map(l => '  ' + l).join('\n'));
+          }
+          console.log('');
+        }
+      }
+    }
+
+  } finally {
+    await fs.remove(stagingDir);
+  }
+}