memoir-cli 1.1.1 → 1.2.1

package/README.md

@@ -28,10 +28,12 @@ No locked-in SaaS, no lost context, no complex shell scripts.
 
 ### Supported Integrations
 - [x] **Gemini CLI**
-- [x] **Claude CLI**
+- [x] **Claude Code**
 - [x] **OpenAI Codex CLI**
-- [ ] *Cursor (Coming Soon)*
-- [ ] *GitHub Copilot (Coming Soon)*
+- [x] **Cursor**
+- [x] **GitHub Copilot**
+- [x] **Windsurf**
+- [x] **Aider**
 
 ---
 

package/bin/memoir.js

@@ -6,17 +6,25 @@ import gradient from 'gradient-string';
 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';
 
-const VERSION = '1.0.0';
+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();
@@ -29,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();
@@ -42,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();
@@ -52,15 +60,27 @@ program
     }
   });
 
+program
+  .command('status')
+  .description('See what AI tools are on this machine')
+  .action(async () => {
+    try {
+      await statusCommand();
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
 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.1.1",
+  "version": "1.2.1",
   "description": "Your AI remembers everything. Sync it everywhere.",
   "main": "src/index.js",
   "type": "module",

package/src/adapters/index.js

@@ -5,6 +5,9 @@ import chalk from 'chalk';
 
 const home = os.homedir();
 
+const isWin = process.platform === 'win32';
+const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+
 export const adapters = [
   {
     name: 'Gemini CLI',
@@ -31,21 +34,77 @@ export const adapters = [
       const ignored = ['.git', 'sessions', 'cache'];
       return !ignored.includes(basename) && !basename.endsWith('.key') && basename !== '.env';
     }
+  },
+  {
+    name: 'Cursor',
+    source: isWin
+      ? path.join(appData, 'Cursor', 'User')
+      : path.join(home, 'Library', 'Application Support', 'Cursor', 'User'),
+    filter: (src) => {
+      const basename = path.basename(src);
+      const ignored = ['globalStorage', 'workspaceStorage', 'CachedData', 'Cache', 'GPUCache', 'logs', 'History', 'Backups', 'snippets'];
+      return !ignored.includes(basename);
+    }
+  },
+  {
+    name: 'GitHub Copilot',
+    source: isWin
+      ? path.join(appData, 'GitHub Copilot')
+      : path.join(home, '.config', 'github-copilot'),
+    filter: (src) => {
+      const basename = path.basename(src);
+      const ignored = ['hosts.json', 'apps.json', 'versions.json'];
+      return !ignored.includes(basename);
+    }
+  },
+  {
+    name: 'Windsurf',
+    source: isWin
+      ? path.join(appData, 'Windsurf', 'User')
+      : path.join(home, 'Library', 'Application Support', 'Windsurf', 'User'),
+    filter: (src) => {
+      const basename = path.basename(src);
+      const ignored = ['workspaceStorage', 'CachedData', 'Cache', 'GPUCache', 'logs', 'History', 'Backups', 'memories', 'snippets'];
+      return !ignored.includes(basename);
+    }
+  },
+  {
+    name: 'Aider',
+    source: home,
+    customExtract: true,
+    files: ['.aider.conf.yml', '.aider.system-prompt.md'],
+    filter: () => true
   }
 ];
 
 export async function extractMemories(stagingDir, spinner) {
   let foundAny = false;
-  
+
   for (const adapter of adapters) {
-    if (await fs.pathExists(adapter.source)) {
+    if (adapter.customExtract) {
+      // Handle tools with individual files (e.g. Aider)
+      const dest = path.join(stagingDir, adapter.name.toLowerCase().replace(/ /g, '-'));
+      let foundFile = false;
+      for (const file of adapter.files) {
+        const filePath = path.join(adapter.source, file);
+        if (await fs.pathExists(filePath)) {
+          if (!foundFile) {
+            spinner.text = `Found ${chalk.cyan(adapter.name)} config... copying to staging`;
+            await fs.ensureDir(dest);
+            foundFile = true;
+          }
+          await fs.copy(filePath, path.join(dest, file));
+        }
+      }
+      if (foundFile) foundAny = true;
+    } else if (await fs.pathExists(adapter.source)) {
       spinner.text = `Found ${chalk.cyan(adapter.name)} memory... copying to staging`;
-      const dest = path.join(stagingDir, adapter.name.toLowerCase().replace(' ', '-'));
+      const dest = path.join(stagingDir, adapter.name.toLowerCase().replace(/ /g, '-'));
       await fs.ensureDir(dest);
       await fs.copy(adapter.source, dest, { filter: adapter.filter });
       foundAny = true;
     }
   }
-  
+
   return foundAny;
 }

package/src/adapters/restore.js

@@ -9,11 +9,11 @@ export async function restoreMemories(sourceDir, spinner) {
   let restoredAny = false;
 
   for (const adapter of adapters) {
-    const backupDir = path.join(sourceDir, adapter.name.toLowerCase().replace(' ', '-'));
-    
+    const backupDir = path.join(sourceDir, adapter.name.toLowerCase().replace(/ /g, '-'));
+
     if (await fs.pathExists(backupDir)) {
       spinner.stop();
-      
+
       console.log('\\n' + chalk.yellow(`⚠ Found backup for ${chalk.bold(adapter.name)}.`));
       const { confirm } = await inquirer.prompt([
         {
@@ -25,12 +25,20 @@ export async function restoreMemories(sourceDir, spinner) {
       ]);
 
       spinner.start();
-      
+
       if (confirm) {
-        spinner.text = `Restoring ${chalk.cyan(adapter.name)} memory to ${adapter.source}...`;
-        await fs.ensureDir(adapter.source);
-        // Copy files from backup to the real source directory
-        await fs.copy(backupDir, adapter.source, { overwrite: true });
+        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 });
+          }
+        } 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 });
+        }
         restoredAny = true;
       } else {
         spinner.info(chalk.gray(`Skipped restoring ${adapter.name}.`));

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

@@ -0,0 +1,63 @@
+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';
+
+export async function statusCommand() {
+  const config = await getConfig();
+
+  console.log();
+
+  // Config status
+  let configLine;
+  if (config) {
+    const provider = config.provider === 'git'
+      ? chalk.cyan(config.gitRepo)
+      : chalk.cyan(config.localPath);
+    configLine = chalk.green('✔ Connected') + chalk.gray(' → ') + provider;
+  } else {
+    configLine = chalk.red('✖ Not configured') + chalk.gray(' → run ') + chalk.cyan('memoir init');
+  }
+
+  // Detected tools
+  const lines = [];
+  let detected = 0;
+
+  for (const adapter of adapters) {
+    let found = false;
+    if (adapter.customExtract) {
+      for (const file of adapter.files) {
+        if (await fs.pathExists(path.join(adapter.source, file))) {
+          found = true;
+          break;
+        }
+      }
+    } else {
+      found = await fs.pathExists(adapter.source);
+    }
+
+    if (found) {
+      lines.push(chalk.green('  ✔ ') + chalk.white(adapter.name));
+      detected++;
+    } else {
+      lines.push(chalk.gray('  ○ ' + adapter.name));
+    }
+  }
+
+  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');
+}

package/src/providers/index.js

@@ -24,20 +24,46 @@ export async function syncToGit(config, stagingDir, spinner) {
   
   spinner.text = `Authenticating and syncing with Git remote: ${chalk.cyan(repoUrl)}`;
   
+  // Clone existing repo to preserve history, then replace contents
+  const gitDir = path.join(os.tmpdir(), `memoir-git-${Date.now()}`);
+  await fs.ensureDir(gitDir);
+
   try {
-    execSync('git init', { cwd: stagingDir, stdio: 'ignore' });
-    execSync('git branch -m main', { cwd: stagingDir, stdio: 'ignore' });
-    execSync('git add .', { cwd: stagingDir, stdio: 'ignore' });
-    execSync('git config user.name "memoir"', { cwd: stagingDir, stdio: 'ignore' });
-    execSync('git config user.email "bot@memoir.dev"', { cwd: stagingDir, stdio: 'ignore' });
-    execSync('git commit -m "chore: memoir backup"', { cwd: stagingDir, stdio: 'ignore' });
-    
+    try {
+      execSync(`git clone --depth 10 ${repoUrl} .`, { cwd: gitDir, stdio: 'ignore' });
+      // Remove old files so deleted configs don't persist
+      const files = await fs.readdir(gitDir);
+      for (const f of files) {
+        if (f !== '.git') await fs.remove(path.join(gitDir, f));
+      }
+    } catch {
+      // Repo is empty or doesn't exist yet — init fresh
+      execSync('git init', { cwd: gitDir, stdio: 'ignore' });
+      execSync('git branch -m main', { cwd: gitDir, stdio: 'ignore' });
+    }
+
+    // Copy staged memories into the git dir
+    await fs.copy(stagingDir, gitDir);
+
+    execSync('git add -A', { cwd: gitDir, stdio: 'ignore' });
+    execSync('git config user.name "memoir"', { cwd: gitDir, stdio: 'ignore' });
+    execSync('git config user.email "bot@memoir.dev"', { cwd: gitDir, stdio: 'ignore' });
+
+    const timestamp = new Date().toISOString().split('T')[0];
+    try {
+      execSync(`git commit -m "memoir backup ${timestamp}"`, { cwd: gitDir, stdio: 'ignore' });
+    } catch {
+      spinner.succeed(chalk.green('Already up to date! ') + chalk.gray('No changes to push.'));
+      return;
+    }
+
     spinner.text = `Pushing data to ${chalk.cyan(repoUrl)}...`;
-    // We ignore stdio to prevent spam, but if it fails it will throw
-    execSync(`git push --force ${repoUrl} main`, { cwd: stagingDir, stdio: 'ignore' });
-    
+    execSync(`git push ${repoUrl} main`, { cwd: gitDir, stdio: 'ignore' });
+
     spinner.succeed(chalk.green('Sync complete! ') + chalk.gray('(Uploaded securely to GitHub)'));
   } catch (err) {
-    throw new Error('Failed to push to git repository. Ensure your SSH keys are configured and the repository exists.');
+    throw new Error('Failed to push to git repository. Ensure your credentials are configured and the repository exists.');
+  } finally {
+    await fs.remove(gitDir);
   }
 }