memoir-cli 1.2.0 → 1.3.0

package/bin/memoir.js

@@ -8,16 +8,23 @@ import { pushCommand } from '../src/commands/push.js';
 import { restoreCommand } from '../src/commands/restore.js';
 import { statusCommand } from '../src/commands/status.js';
 
-const VERSION = '1.1.1';
+const VERSION = '1.2.0';
+
+// Custom help banner
+program.addHelpText('beforeAll', '\n' + boxen(
+  gradient.pastel.multiline('  memoir  ') + '\n' +
+  chalk.gray('  Your AI remembers everything.'),
+  { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
+) + '\n');
 
 program
   .name('memoir')
-  .description('Your AI remembers everything. Sync it everywhere.')
+  .description(chalk.white('Sync your AI memory across every device.'))
   .version(VERSION);
 
 program
   .command('init')
-  .description('Initialize and configure memoir storage preferences')
+  .description('Set up memoir with your storage provider')
   .action(async () => {
     try {
       await initCommand();
@@ -30,7 +37,7 @@ program
 program
   .command('push')
   .alias('remember')
-  .description('Sync your AI memory to your configured storage')
+  .description('Back up your AI memory to the cloud')
   .action(async () => {
     try {
       await pushCommand();
@@ -43,7 +50,7 @@ program
 program
   .command('restore')
   .alias('pull')
-  .description('Restore your AI memory from your configured storage')
+  .description('Restore your AI memory on this machine')
   .action(async () => {
     try {
       await restoreCommand();
@@ -55,7 +62,7 @@ program
 
 program
   .command('status')
-  .description('Show detected AI tools and configuration status')
+  .description('See what AI tools are on this machine')
   .action(async () => {
     try {
       await statusCommand();
@@ -67,13 +74,13 @@ program
 
 program
   .command('migrate')
-  .description('Migrate memory/context from one AI bot to another (e.g. Claude to Gemini)')
+  .description('Translate memory between AI providers')
   .action(() => {
     console.log('\n' + boxen(
-      gradient.pastel('memoir migrate (Coming Soon)') + '\n\n' +
-      chalk.white('We are actively developing the ability to instantly translate') + '\n' +
-      chalk.white('and swap your context/memories between different AI providers.') + '\n\n' +
-      chalk.cyan('Stay tuned for updates!'),
+      gradient.pastel('  memoir migrate  ') + '\n\n' +
+      chalk.white('Instantly translate your context between') + '\n' +
+      chalk.white('Claude, Gemini, Codex, and more.') + '\n\n' +
+      chalk.cyan.bold('Coming soon.'),
       { padding: 1, borderStyle: 'round', borderColor: 'yellow', align: 'center' }
     ) + '\n');
   });

package/package.json

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

package/src/adapters/restore.js

@@ -5,6 +5,25 @@ import os from 'os';
 import inquirer from 'inquirer';
 import { adapters } from '../adapters/index.js';
 
+async function copyMissing(src, dest, spinner) {
+  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, spinner);
+    } else {
+      if (await fs.pathExists(destPath)) {
+        // skip existing files
+      } else {
+        await fs.copy(srcPath, destPath);
+      }
+    }
+  }
+}
+
 export async function restoreMemories(sourceDir, spinner) {
   let restoredAny = false;
 
@@ -19,7 +38,7 @@ export async function restoreMemories(sourceDir, spinner) {
         {
           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
         }
       ]);
@@ -28,16 +47,22 @@ export async function restoreMemories(sourceDir, spinner) {
 
       if (confirm) {
         if (adapter.customExtract) {
-          // Restore individual files back to their original locations
+          // Restore individual files — only add missing ones
           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)) {
+              spinner.info(chalk.gray(`  Skipped ${file} (already exists)`));
+              spinner.start();
+            } else {
+              await fs.copy(path.join(backupDir, file), 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 });
+          // Merge — only copy files that don't already exist
+          await copyMissing(backupDir, adapter.source, spinner);
         }
         restoredAny = true;
       } else {

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/push.js

@@ -3,48 +3,82 @@ 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 { extractMemories } from '../adapters/index.js';
+import { extractMemories, adapters } from '../adapters/index.js';
 import { syncToLocal, syncToGit } from '../providers/index.js';
 
 export async function pushCommand() {
   const config = await getConfig();
-  
+
   if (!config) {
-    console.log('\\n' + chalk.red('✖ memoir is not configured.'));
-    console.log(`Run ${chalk.cyan('memoir init')} to set up your storage provider.\\n`);
+    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('Initializing AI memory sync...').start();
+  const spinner = ora({ text: chalk.gray('Scanning for AI tools...'), spinner: 'dots' }).start();
 
-  // Create a temporary staging directory
   const stagingDir = path.join(os.tmpdir(), `memoir-staging-${Date.now()}`);
   await fs.ensureDir(stagingDir);
 
   try {
-    spinner.text = 'Scanning system for AI configurations...';
-    
-    // Pass spinner so adapter can update it
     const foundAny = await extractMemories(stagingDir, spinner);
-    
+
     if (!foundAny) {
-      spinner.warn(chalk.yellow('No supported AI memory folders found on this system.'));
+      spinner.stop();
+      console.log('\n' + boxen(
+        chalk.yellow('No AI tools detected on this machine.\n\n') +
+        chalk.gray('Supported: Claude, Gemini, Codex, Cursor, Copilot, Windsurf, Aider'),
+        { padding: 1, borderStyle: 'round', borderColor: 'yellow' }
+      ) + '\n');
       return;
     }
 
+    // Count what was found
+    const found = [];
+    for (const adapter of adapters) {
+      if (adapter.customExtract) {
+        for (const file of adapter.files) {
+          if (await fs.pathExists(path.join(adapter.source, file))) {
+            found.push(adapter.name);
+            break;
+          }
+        }
+      } else if (await fs.pathExists(adapter.source)) {
+        found.push(adapter.name);
+      }
+    }
+
+    spinner.text = chalk.gray('Uploading to ' + (config.provider === 'git' ? 'GitHub' : 'local storage') + '...');
+
     if (config.provider === 'local' || config.provider.includes('local')) {
       await syncToLocal(config, stagingDir, spinner);
     } else if (config.provider === 'git' || config.provider.includes('git')) {
       await syncToGit(config, stagingDir, spinner);
     } else {
       spinner.fail(chalk.red(`Unknown provider: ${config.provider}`));
+      return;
     }
+
+    spinner.stop();
+
+    // 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'}`),
+      { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
+    ) + '\n');
   } catch (error) {
     spinner.fail(chalk.red('Sync failed: ') + error.message);
   } finally {
-    // Clean up staging directory
     await fs.remove(stagingDir);
   }
 }

package/src/commands/restore.js

@@ -3,22 +3,26 @@ 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 { fetchFromLocal, fetchFromGit } from '../providers/restore.js';
 
 export async function restoreCommand() {
   const config = await getConfig();
-  
+
   if (!config) {
-    console.log('\\n' + chalk.red('✖ memoir is not configured.'));
-    console.log(`Run ${chalk.cyan('memoir init')} to set up your storage provider and fetch your files.\\n`);
+    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('Initializing AI memory restore...').start();
+  const spinner = ora({ text: chalk.gray('Fetching memories from ' + (config.provider === 'git' ? 'GitHub' : 'local storage') + '...'), spinner: 'dots' }).start();
 
-  // Create a temporary staging directory to hold the downloaded files
   const stagingDir = path.join(os.tmpdir(), `memoir-restore-${Date.now()}`);
   await fs.ensureDir(stagingDir);
 
@@ -34,16 +38,26 @@ export async function restoreCommand() {
       return;
     }
 
+    spinner.stop();
+
     if (restored) {
-      spinner.succeed(chalk.green('Restore complete! Your AI bots have their memories back.'));
+      console.log('\n' + boxen(
+        gradient.pastel('  Restored!  ') + '\n\n' +
+        chalk.white('Your AI tools have their memories back.') + '\n' +
+        chalk.gray('They remember everything.'),
+        { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
+      ) + '\n');
     } else {
-      spinner.info(chalk.yellow('No memories were restored.'));
+      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.'),
+        { padding: 1, borderStyle: 'round', borderColor: 'yellow' }
+      ) + '\n');
     }
 
   } catch (error) {
     spinner.fail(chalk.red('Restore failed: ') + error.message);
   } finally {
-    // Clean up staging directory
     await fs.remove(stagingDir);
   }
 }

package/src/commands/status.js

@@ -1,6 +1,8 @@
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
+import boxen from 'boxen';
+import gradient from 'gradient-string';
 import { getConfig } from '../config.js';
 import { adapters } from '../adapters/index.js';
 
@@ -10,47 +12,52 @@ export async function statusCommand() {
   console.log();
 
   // Config status
+  let configLine;
   if (config) {
-    const provider = config.provider === 'git' ? `Git (${config.gitRepo})` : `Local (${config.localPath})`;
-    console.log(chalk.green('✔ Configured') + chalk.gray(` — ${provider}`));
+    const provider = config.provider === 'git'
+      ? chalk.cyan(config.gitRepo)
+      : chalk.cyan(config.localPath);
+    configLine = chalk.green('✔ Connected') + chalk.gray(' → ') + provider;
   } else {
-    console.log(chalk.red('✖ Not configured') + chalk.gray(' — run memoir init'));
-    console.log();
-    return;
+    configLine = chalk.red('✖ Not configured') + chalk.gray(' → run ') + chalk.cyan('memoir init');
   }
 
-  console.log();
-
   // Detected tools
-  console.log(chalk.bold('Detected AI tools:\n'));
-
+  const lines = [];
   let detected = 0;
+
   for (const adapter of adapters) {
+    let found = false;
     if (adapter.customExtract) {
-      let hasFiles = false;
       for (const file of adapter.files) {
         if (await fs.pathExists(path.join(adapter.source, file))) {
-          hasFiles = true;
+          found = true;
           break;
         }
       }
-      if (hasFiles) {
-        console.log(chalk.green('  ✔ ') + adapter.name);
-        detected++;
-      } else {
-        console.log(chalk.gray('  ○ ') + chalk.gray(adapter.name + ' — not found'));
-      }
     } else {
-      if (await fs.pathExists(adapter.source)) {
-        console.log(chalk.green('  ✔ ') + adapter.name);
-        detected++;
-      } else {
-        console.log(chalk.gray('  ○ ') + chalk.gray(adapter.name + ' — not found'));
-      }
+      found = await fs.pathExists(adapter.source);
+    }
+
+    if (found) {
+      lines.push(chalk.green('  ✔ ') + chalk.white(adapter.name));
+      detected++;
+    } else {
+      lines.push(chalk.gray('  ○ ' + adapter.name));
     }
   }
 
-  console.log();
-  console.log(chalk.white(`${detected} tool${detected !== 1 ? 's' : ''} detected on this machine.`));
-  console.log();
+  const summary = detected > 0
+    ? chalk.white(`${detected} tool${detected !== 1 ? 's' : ''} ready to sync`)
+    : chalk.yellow('No AI tools detected');
+
+  console.log(boxen(
+    gradient.pastel('  memoir status  ') + '\n\n' +
+    configLine + '\n\n' +
+    chalk.bold.white('AI Tools') + '\n' +
+    lines.join('\n') + '\n\n' +
+    chalk.gray('─'.repeat(30)) + '\n' +
+    summary,
+    { padding: 1, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
+  ) + '\n');
 }