memoir-cli 2.1.0 → 2.2.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 { doctorCommand } from '../src/commands/doctor.js';
 import { viewCommand } from '../src/commands/view.js';
 import { diffCommand } from '../src/commands/diff.js';
 import { migrateCommand } from '../src/commands/migrate.js';
@@ -26,11 +27,17 @@ async function checkForUpdate() {
     clearTimeout(timeout);
     const data = await res.json();
     const latest = data.version;
-    if (latest && latest !== VERSION) {
+    // Only notify if remote is actually newer (not just different)
+    const isNewer = (a, b) => {
+      const [a1, a2, a3] = a.split('.').map(Number);
+      const [b1, b2, b3] = b.split('.').map(Number);
+      return a1 > b1 || (a1 === b1 && a2 > b2) || (a1 === b1 && a2 === b2 && a3 > b3);
+    };
+    if (latest && isNewer(latest, VERSION)) {
       console.log(
         '\n' + boxen(
           chalk.yellow(`Update available: ${VERSION} → ${chalk.green.bold(latest)}`) + '\n' +
-          chalk.gray('Run: ') + chalk.cyan('npm install -g memoir-cli'),
+          chalk.gray('Run: ') + chalk.cyan('memoir update'),
           { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'yellow', dimBorder: true }
         )
       );
@@ -49,7 +56,8 @@ if (process.argv.length <= 2) {
     chalk.cyan('  memoir restore   ') + chalk.gray('— restore on a new machine') + '\n' +
     chalk.cyan('  memoir snapshot  ') + chalk.gray('— capture your current session') + '\n' +
     chalk.cyan('  memoir resume    ') + chalk.gray('— pick up where you left off') + '\n' +
-    chalk.cyan('  memoir status    ') + chalk.gray('— see detected AI tools') + '\n\n' +
+    chalk.cyan('  memoir status    ') + chalk.gray('— see detected AI tools') + '\n' +
+    chalk.cyan('  memoir update    ') + chalk.gray('— update to latest version') + '\n\n' +
     chalk.gray('  Tip: use --only claude,gemini to sync specific tools') + '\n\n' +
     chalk.gray(`v${VERSION}`),
     { padding: 1, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
@@ -122,6 +130,19 @@ program
     }
   });
 
+program
+  .command('doctor')
+  .alias('diagnose')
+  .description('Diagnose common issues with your memoir setup')
+  .action(async () => {
+    try {
+      await doctorCommand();
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
 program
   .command('view')
   .alias('ls')
@@ -177,6 +198,47 @@ program
     }
   });
 
+program
+  .command('update')
+  .alias('upgrade')
+  .description('Update memoir to the latest version')
+  .action(async () => {
+    try {
+      const res = await fetch('https://registry.npmjs.org/memoir-cli/latest');
+      const data = await res.json();
+      const latest = data.version;
+
+      if (latest === VERSION) {
+        console.log('\n' + boxen(
+          chalk.green('✔ Already up to date!') + '\n' +
+          chalk.gray(`v${VERSION}`),
+          { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'green', dimBorder: true }
+        ) + '\n');
+        return;
+      }
+
+      console.log('\n' + chalk.cyan(`Updating memoir ${VERSION} → ${chalk.green.bold(latest)}...`) + '\n');
+
+      const { execSync } = await import('child_process');
+      // Detect package manager — prefer the one that installed memoir
+      const execPath = process.argv[1] || '';
+      const useBun = execPath.includes('.bun') || process.env.BUN_INSTALL;
+      const cmd = useBun ? 'bun install -g memoir-cli' : 'npm install -g memoir-cli';
+
+      execSync(cmd, { stdio: 'inherit' });
+
+      console.log('\n' + boxen(
+        gradient.pastel('  Updated!  ') + '\n\n' +
+        chalk.white(`memoir ${VERSION} → ${chalk.green.bold(latest)}`),
+        { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
+      ) + '\n');
+    } catch (err) {
+      console.error(chalk.red('\n✖ Update failed:'), err.message);
+      console.log(chalk.gray('Try manually: ') + chalk.cyan('npm install -g memoir-cli'));
+      process.exit(1);
+    }
+  });
+
 program
   .command('migrate')
   .description('Translate memory between AI tools (Claude, Gemini, Codex, Cursor, etc.)')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memoir-cli",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "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.",
   "main": "src/index.js",
   "type": "module",

package/src/adapters/index.js

@@ -127,6 +127,80 @@ export const adapters = [
       return false;
     }
   },
+  {
+    name: 'Zed',
+    icon: '🔶',
+    source: isWin
+      ? path.join(appData, 'Zed')
+      : path.join(home, '.config', 'zed'),
+    filter: (src) => {
+      const zedDir = isWin
+        ? path.join(appData, 'Zed')
+        : path.join(home, '.config', 'zed');
+      const rel = path.relative(zedDir, src);
+      if (src === zedDir) return true;
+      const basename = path.basename(src);
+      // Skip known heavy/non-config directories
+      const skipDirs = ['extensions', 'themes', 'logs', 'db', 'copilot', 'node', 'languages'];
+      const topDir = rel.split(path.sep)[0];
+      if (skipDirs.includes(topDir)) return false;
+      // Only sync specific config files in root
+      const allowed = ['settings.json', 'keymap.json', 'tasks.json'];
+      if (allowed.includes(basename) && !rel.includes(path.sep)) return true;
+      // Allow .md files in root
+      if (basename.endsWith('.md') && !rel.includes(path.sep)) return true;
+      return false;
+    }
+  },
+  {
+    name: 'Cline',
+    icon: '🤖',
+    source: isWin
+      ? path.join(appData, 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev')
+      : path.join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev'),
+    filter: (src) => {
+      const clineDir = isWin
+        ? path.join(appData, 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev')
+        : path.join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev');
+      const rel = path.relative(clineDir, src);
+      if (src === clineDir) return true;
+      const basename = path.basename(src);
+      const topDir = rel.split(path.sep)[0];
+      // Skip known heavy/non-config directories
+      const skipDirs = ['tasks', 'checkpoints', '.cache', 'images'];
+      if (skipDirs.includes(topDir)) return false;
+      // Allow settings/ and rules/ directories
+      if (topDir === 'settings' || topDir === 'rules') return true;
+      // Allow .md files in root
+      if (basename.endsWith('.md') && !rel.includes(path.sep)) return true;
+      return false;
+    }
+  },
+  {
+    name: 'Continue.dev',
+    icon: '🔄',
+    source: isWin
+      ? path.join(process.env.USERPROFILE || home, '.continue')
+      : path.join(home, '.continue'),
+    filter: (src) => {
+      const continueDir = isWin
+        ? path.join(process.env.USERPROFILE || home, '.continue')
+        : path.join(home, '.continue');
+      const rel = path.relative(continueDir, src);
+      if (src === continueDir) return true;
+      const basename = path.basename(src);
+      // Skip known heavy/non-config directories
+      const skipDirs = ['sessions', 'dev_data', 'logs', 'index', 'cache', 'types'];
+      const topDir = rel.split(path.sep)[0];
+      if (skipDirs.includes(topDir)) return false;
+      // Only sync specific config files in root
+      const allowed = ['config.json', 'config.ts', 'config.yaml', '.continuerules'];
+      if (allowed.includes(basename) && !rel.includes(path.sep)) return true;
+      // Allow .md files in root
+      if (basename.endsWith('.md') && !rel.includes(path.sep)) return true;
+      return false;
+    }
+  },
   {
     name: 'Aider',
     icon: '🔧',

package/src/adapters/restore.js

@@ -5,27 +5,115 @@ import os from 'os';
 import inquirer from 'inquirer';
 import { adapters } from '../adapters/index.js';
 
+// Detect the local home key by looking at what Claude has ALREADY created
+// on this machine, rather than trying to compute the encoding ourselves.
+// Claude's path encoding varies across platforms and versions, so detection
+// is the only reliable approach.
+function detectLocalHomeKey(adapterSource) {
+  const localProjectsDir = path.join(adapterSource, 'projects');
+  if (!fs.existsSync(localProjectsDir)) return null;
+
+  const entries = fs.readdirSync(localProjectsDir)
+    .filter(e => fs.statSync(path.join(localProjectsDir, e)).isDirectory());
+  if (entries.length === 0) return null;
+
+  // Find dirs with a memory/ subfolder that aren't sub-projects of another dir
+  const candidates = entries.filter(entry => {
+    const hasMemory = fs.existsSync(path.join(localProjectsDir, entry, 'memory'));
+    if (!hasMemory) return false;
+    // A sub-project dir starts with another dir + '-'
+    const isSubProject = entries.some(other =>
+      other !== entry && entry.startsWith(other + '-')
+    );
+    return !isSubProject;
+  });
+
+  if (candidates.length === 1) return candidates[0];
+
+  if (candidates.length > 1) {
+    // Multiple home-key candidates (e.g. encoding changed between Claude versions)
+    // Pick the most recently modified one — that's what Claude is actively using
+    return candidates.sort((a, b) => {
+      const aDir = path.join(localProjectsDir, a, 'memory');
+      const bDir = path.join(localProjectsDir, b, 'memory');
+      return fs.statSync(bDir).mtimeMs - fs.statSync(aDir).mtimeMs;
+    })[0];
+  }
+
+  // No dir has memory/ — fall back to shortest dir that's a prefix of others
+  const prefixDirs = entries.filter(entry =>
+    entries.some(other => other !== entry && other.startsWith(entry + '-'))
+  ).sort((a, b) => a.length - b.length);
+
+  return prefixDirs[0] || entries[0];
+}
+
 // Claude CLI stores projects under paths like `projects/-Users-camarthur/`
-// This converts the path from the backup machine to match the current machine
-function remapProjectPath(backupDir, adapterSource) {
+// This remaps ALL foreign machine dirs to match the current machine.
+function remapProjectPaths(backupDir, adapterSource) {
   const projectsDir = path.join(backupDir, 'projects');
-  if (!fs.existsSync(projectsDir)) return null;
+  if (!fs.existsSync(projectsDir)) return [];
 
-  const entries = fs.readdirSync(projectsDir);
-  // Find the backed-up home dir key (e.g., "-Users-camarthur")
-  const oldHomeKey = entries.find(e => {
-    return fs.statSync(path.join(projectsDir, e)).isDirectory();
-  });
-  if (!oldHomeKey) return null;
+  const backupEntries = fs.readdirSync(projectsDir)
+    .filter(e => fs.statSync(path.join(projectsDir, e)).isDirectory());
+  if (backupEntries.length === 0) return [];
+
+  // Step 1: Detect the local home key from existing Claude dirs
+  let localHomeKey = detectLocalHomeKey(adapterSource);
+
+  // Step 2: Fallback — compute from homedir (only for fresh installs)
+  if (!localHomeKey) {
+    const home = os.homedir();
+    // Use the same encoding Claude uses: path with separators → dashes
+    localHomeKey = '-' + home.replace(/^\//, '').replace(/\\/g, '-').replace(/\//g, '-').replace(/:/g, '');
+  }
 
-  // Build the current machine's home dir key
-  // Claude uses the homedir path with / replaced by - and leading -
-  const home = os.homedir();
-  const newHomeKey = '-' + home.replace(/^\//, '').replace(/\\/g, '-').replace(/\//g, '-').replace(/:/g, '');
+  // Step 3: Identify foreign home keys in the backup
+  // A "home key" is a dir that: has memory/, OR is a prefix of other dirs, AND is not a sub-project
+  const foreignHomeKeys = new Set();
+
+  for (const entry of backupEntries) {
+    // Skip dirs that already belong to this machine
+    if (entry === localHomeKey || entry.startsWith(localHomeKey + '-')) continue;
+
+    // Is this a sub-project of another backup dir? Then skip — its parent handles it
+    const isSubProject = backupEntries.some(other =>
+      other !== entry && entry.startsWith(other + '-')
+    );
+    if (isSubProject) continue;
+
+    // Has memory/ subfolder = definitely a home key
+    const hasMemory = fs.existsSync(path.join(projectsDir, entry, 'memory'));
+    // Is a prefix of other dirs = likely a home key
+    const isPrefix = backupEntries.some(other =>
+      other !== entry && other.startsWith(entry + '-')
+    );
+
+    if (hasMemory || isPrefix) {
+      foreignHomeKeys.add(entry);
+    }
+  }
 
-  if (oldHomeKey === newHomeKey) return null; // Same machine, no remap needed
+  // Step 4: Build remaps — remap each foreign home key and its sub-projects
+  const remaps = [];
+  const processed = new Set();
+
+  for (const foreignKey of foreignHomeKeys) {
+    // Find all dirs belonging to this foreign home key
+    for (const dir of backupEntries) {
+      if (processed.has(dir)) continue;
+      if (dir !== foreignKey && !dir.startsWith(foreignKey + '-')) continue;
+
+      processed.add(dir);
+      const suffix = dir.slice(foreignKey.length); // "" or "-alfred" etc.
+      const newName = localHomeKey + suffix;
+      if (dir !== newName) {
+        remaps.push({ oldName: dir, newName });
+      }
+    }
+  }
 
-  return { oldHomeKey, newHomeKey };
+  return remaps;
 }
 
 async function syncFiles(src, dest, changes) {
@@ -97,17 +185,24 @@ export async function restoreMemories(sourceDir, spinner, onlyFilter = null, aut
 
         // Remap Claude project paths from source machine to this machine
         if (adapter.name === 'Claude CLI') {
-          const remap = remapProjectPath(backupDir, adapter.source);
-          if (remap) {
+          const remaps = remapProjectPaths(backupDir, adapter.source);
+          if (remaps.length > 0) {
             spinner.stop();
-            console.log(chalk.gray(`  Remapping project path: ${remap.oldHomeKey} → ${remap.newHomeKey}`));
-            spinner.start();
-            // Rename the directory in staging so it restores to the right place
-            const oldDir = path.join(backupDir, 'projects', remap.oldHomeKey);
-            const newDir = path.join(backupDir, 'projects', remap.newHomeKey);
-            if (await fs.pathExists(oldDir) && !(await fs.pathExists(newDir))) {
-              await fs.move(oldDir, newDir);
+            for (const remap of remaps) {
+              console.log(chalk.gray(`  Remapping: ${remap.oldName} → ${remap.newName}`));
+              const oldDir = path.join(backupDir, 'projects', remap.oldName);
+              const newDir = path.join(backupDir, 'projects', remap.newName);
+              if (await fs.pathExists(oldDir)) {
+                if (await fs.pathExists(newDir)) {
+                  // Merge into existing directory
+                  await syncFiles(oldDir, newDir, { added: [], updated: [], skipped: [] });
+                  await fs.remove(oldDir);
+                } else {
+                  await fs.move(oldDir, newDir);
+                }
+              }
             }
+            spinner.start();
           }
         }
 

package/src/commands/doctor.js

@@ -0,0 +1,223 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import boxen from 'boxen';
+import ora from 'ora';
+import gradient from 'gradient-string';
+import os from 'os';
+import { execSync } from 'child_process';
+import { getConfig } from '../config.js';
+import { adapters } from '../adapters/index.js';
+
+const SECRET_PATTERNS = [
+  { pattern: /sk-[a-zA-Z0-9]{20,}/, label: 'OpenAI/Stripe secret key' },
+  { pattern: /key-[a-zA-Z0-9]{20,}/, label: 'API key' },
+  { pattern: /ghp_[a-zA-Z0-9]{36,}/, label: 'GitHub personal access token' },
+  { pattern: /gho_[a-zA-Z0-9]{36,}/, label: 'GitHub OAuth token' },
+  { pattern: /AKIA[0-9A-Z]{16}/, label: 'AWS access key' },
+  { pattern: /Bearer\s+[a-zA-Z0-9._\-]{20,}/, label: 'Bearer token' },
+];
+
+const SENSITIVE_FILENAMES = ['.env', 'credentials', 'token.json'];
+
+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`;
+}
+
+async function collectFiles(dir, filter) {
+  const files = [];
+  async function walk(d) {
+    let entries;
+    try {
+      entries = await fs.readdir(d, { withFileTypes: true });
+    } catch { return; }
+    for (const entry of entries) {
+      const fullPath = path.join(d, entry.name);
+      if (entry.isDirectory()) {
+        if (filter && !filter(fullPath)) continue;
+        await walk(fullPath);
+      } else {
+        if (filter && !filter(fullPath)) continue;
+        files.push(fullPath);
+      }
+    }
+  }
+  await walk(dir);
+  return files;
+}
+
+async function scanForSecrets(files) {
+  const warnings = [];
+  for (const filePath of files) {
+    const basename = path.basename(filePath);
+    if (SENSITIVE_FILENAMES.includes(basename)) {
+      warnings.push({ file: filePath, reason: `Sensitive filename: ${basename}` });
+      continue;
+    }
+    try {
+      const stat = await fs.stat(filePath);
+      // Skip files larger than 1MB
+      if (stat.size > 1024 * 1024) continue;
+      const content = await fs.readFile(filePath, 'utf-8');
+      for (const { pattern, label } of SECRET_PATTERNS) {
+        if (pattern.test(content)) {
+          warnings.push({ file: filePath, reason: label });
+          break;
+        }
+      }
+    } catch {
+      // Skip unreadable files
+    }
+  }
+  return warnings;
+}
+
+export async function doctorCommand() {
+  const spinner = ora({ text: 'Running diagnostics...', color: 'cyan' }).start();
+  const lines = [];
+  let passCount = 0;
+  let warnCount = 0;
+  let failCount = 0;
+
+  const pass = (msg) => { passCount++; return chalk.green('  ✔ ') + msg; };
+  const warn = (msg) => { warnCount++; return chalk.yellow('  ⚠ ') + msg; };
+  const fail = (msg) => { failCount++; return chalk.red('  ✖ ') + msg; };
+
+  // 1. Config check
+  spinner.text = 'Checking configuration...';
+  const config = await getConfig();
+  if (config) {
+    const providerLabel = config.provider === 'git' ? 'git' : 'local';
+    const dest = config.provider === 'git' ? config.gitRepo : config.localPath;
+    lines.push(pass(`Config: ${chalk.cyan(providerLabel)} → ${chalk.gray(dest)}`));
+  } else {
+    lines.push(fail(`Config: not initialized — run ${chalk.cyan('memoir init')}`));
+  }
+
+  // 2. Git check
+  spinner.text = 'Checking git...';
+  let gitInstalled = false;
+  try {
+    execSync('git --version', { stdio: 'pipe' });
+    gitInstalled = true;
+    lines.push(pass('Git: installed'));
+  } catch {
+    lines.push(fail('Git: not installed'));
+  }
+
+  if (config?.provider === 'git' && gitInstalled && config.gitRepo) {
+    spinner.text = 'Testing remote connectivity...';
+    try {
+      execSync(`git ls-remote ${config.gitRepo} HEAD`, { stdio: 'pipe', timeout: 10000 });
+      lines.push(pass(`Remote: ${chalk.gray(config.gitRepo)} reachable`));
+    } catch {
+      lines.push(fail(`Remote: cannot reach ${chalk.gray(config.gitRepo)}`));
+    }
+  }
+
+  // 3. AI Tools scan
+  spinner.text = 'Scanning AI tools...';
+  lines.push('');
+  lines.push(chalk.bold.white('  AI Tools'));
+
+  const allSyncFiles = [];
+  let totalSize = 0;
+
+  for (const adapter of adapters) {
+    let found = false;
+    let fileCount = 0;
+    let size = 0;
+    let adapterFiles = [];
+
+    if (adapter.customExtract) {
+      for (const file of adapter.files) {
+        const filePath = path.join(adapter.source, file);
+        if (await fs.pathExists(filePath)) {
+          found = true;
+          fileCount++;
+          try {
+            const stat = await fs.stat(filePath);
+            size += stat.size;
+            adapterFiles.push(filePath);
+          } catch {}
+        }
+      }
+    } else if (await fs.pathExists(adapter.source)) {
+      found = true;
+      adapterFiles = await collectFiles(adapter.source, adapter.filter);
+      fileCount = adapterFiles.length;
+      for (const f of adapterFiles) {
+        try {
+          const stat = await fs.stat(f);
+          size += stat.size;
+        } catch {}
+      }
+    }
+
+    if (found) {
+      lines.push(pass(`${adapter.name}: ${chalk.gray(`${fileCount} files, ${formatSize(size)}`)}`));
+      allSyncFiles.push(...adapterFiles);
+      totalSize += size;
+    } else {
+      lines.push(chalk.gray('  ○ ') + chalk.gray(adapter.name + ': not found'));
+    }
+  }
+
+  // 4. Secrets scan
+  spinner.text = 'Scanning for secrets...';
+  lines.push('');
+  lines.push(chalk.bold.white('  Security'));
+
+  const secretWarnings = await scanForSecrets(allSyncFiles);
+  if (secretWarnings.length === 0) {
+    lines.push(pass('No secrets detected in sync files'));
+  } else {
+    lines.push(warn(`${secretWarnings.length} potential secret${secretWarnings.length !== 1 ? 's' : ''} found:`));
+    for (const w of secretWarnings.slice(0, 5)) {
+      lines.push(chalk.yellow('      → ') + chalk.gray(path.basename(w.file)) + chalk.yellow(` (${w.reason})`));
+    }
+    if (secretWarnings.length > 5) {
+      lines.push(chalk.gray(`      ...and ${secretWarnings.length - 5} more`));
+    }
+  }
+
+  // 5. Disk usage
+  lines.push('');
+  lines.push(chalk.bold.white('  Disk'));
+  lines.push(pass(`Total backup size: ${chalk.cyan(formatSize(totalSize))} across ${chalk.cyan(allSyncFiles.length)} files`));
+
+  // 6. Last sync
+  if (config?.provider === 'git' && gitInstalled && config.gitRepo) {
+    spinner.text = 'Checking last sync...';
+    lines.push('');
+    lines.push(chalk.bold.white('  Last Sync'));
+    try {
+      const tmpDir = path.join(os.tmpdir(), 'memoir-doctor-' + Date.now());
+      execSync(`git clone --depth 1 ${config.gitRepo} ${tmpDir}`, { stdio: 'pipe', timeout: 15000 });
+      const lastCommit = execSync('git log -1 --format=%cr', { cwd: tmpDir, stdio: 'pipe' }).toString().trim();
+      const lastMsg = execSync('git log -1 --format=%s', { cwd: tmpDir, stdio: 'pipe' }).toString().trim();
+      await fs.remove(tmpDir);
+      lines.push(pass(`Last backup: ${chalk.cyan(lastCommit)} — ${chalk.gray(lastMsg)}`));
+    } catch {
+      lines.push(warn('Could not determine last sync time'));
+    }
+  }
+
+  spinner.stop();
+
+  // Summary
+  const summaryParts = [];
+  if (passCount > 0) summaryParts.push(chalk.green(`${passCount} passed`));
+  if (warnCount > 0) summaryParts.push(chalk.yellow(`${warnCount} warning${warnCount !== 1 ? 's' : ''}`));
+  if (failCount > 0) summaryParts.push(chalk.red(`${failCount} failed`));
+
+  console.log('\n' + boxen(
+    gradient.pastel('  memoir doctor  ') + '\n\n' +
+    lines.join('\n') + '\n\n' +
+    chalk.gray('─'.repeat(36)) + '\n' +
+    '  ' + summaryParts.join(chalk.gray(' · ')),
+    { padding: 1, borderStyle: 'round', borderColor: failCount > 0 ? 'red' : warnCount > 0 ? 'yellow' : 'green', dimBorder: true }
+  ) + '\n');
+}

package/src/commands/init.js

@@ -87,7 +87,25 @@ export async function initCommand() {
     const repo = answers.repo.trim();
 
     config.gitRepo = `https://github.com/${username}/${repo}.git`;
-    console.log(chalk.gray(`  → ${config.gitRepo}\n`));
+    console.log(chalk.gray(`  → ${config.gitRepo}`));
+
+    // Auto-create the repo if gh CLI is available and repo doesn't exist
+    if (direction === 'upload') {
+      try {
+        execFileSync('gh', ['repo', 'view', `${username}/${repo}`], { stdio: 'ignore' });
+        console.log(chalk.gray('  ✔ Repo exists\n'));
+      } catch {
+        // Repo doesn't exist — try to create it
+        try {
+          execFileSync('gh', ['repo', 'create', `${username}/${repo}`, '--private', '--description', 'AI memory backup (memoir-cli)'], { stdio: 'ignore' });
+          console.log(chalk.green('  ✔ Created private repo\n'));
+        } catch {
+          console.log(chalk.yellow('  ⚠ Could not auto-create repo. Create it manually on GitHub.\n'));
+        }
+      }
+    } else {
+      console.log('');
+    }
   }
 
   await saveConfig(config);

package/src/commands/status.js

@@ -23,8 +23,8 @@ export async function statusCommand() {
   }
 
   // Detected tools
-  const lines = [];
-  let detected = 0;
+  const foundTools = [];
+  const notFound = [];
 
   for (const adapter of adapters) {
     let found = false;
@@ -40,22 +40,30 @@ export async function statusCommand() {
     }
 
     if (found) {
-      lines.push(chalk.green('  ✔ ') + chalk.white(adapter.name));
-      detected++;
+      foundTools.push(chalk.green('  ✔ ') + chalk.white(adapter.name));
     } else {
-      lines.push(chalk.gray('  ○ ' + adapter.name));
+      notFound.push(adapter.name);
     }
   }
 
-  const summary = detected > 0
-    ? chalk.white(`${detected} tool${detected !== 1 ? 's' : ''} ready to sync`)
-    : chalk.yellow('No AI tools detected');
+  const lines = foundTools.length > 0
+    ? foundTools
+    : [chalk.yellow('  No AI tools detected')];
+
+  const summary = foundTools.length > 0
+    ? chalk.white(`${foundTools.length} tool${foundTools.length !== 1 ? 's' : ''} ready to sync`)
+    : chalk.gray(`Supports: ${adapters.map(a => a.name).join(', ')}`);
+
+  // Show not-found tools as a compact line if there are found tools
+  const notFoundLine = foundTools.length > 0 && notFound.length > 0
+    ? '\n' + chalk.gray(`  Also supports: ${notFound.join(', ')}`)
+    : '';
 
   console.log(boxen(
     gradient.pastel('  memoir status  ') + '\n\n' +
     configLine + '\n\n' +
     chalk.bold.white('AI Tools') + '\n' +
-    lines.join('\n') + '\n\n' +
+    lines.join('\n') + notFoundLine + '\n\n' +
     chalk.gray('─'.repeat(30)) + '\n' +
     summary,
     { padding: 1, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }

package/src/tools/cline.js

@@ -0,0 +1,72 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const home = os.homedir();
+const cwd = process.cwd();
+
+export default {
+  key: 'cline',
+  name: 'Cline',
+  icon: '🤖',
+  format: 'Configuration and rules for Cline AI coding assistant. Includes settings for AI behavior and custom rules files for project-specific instructions.',
+
+  discover() {
+    const files = [];
+    const clineDir = process.platform === 'win32'
+      ? path.join(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev')
+      : path.join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev');
+
+    // Check for .clinerules in project
+    const projectFile = path.join(cwd, '.clinerules');
+    if (fs.existsSync(projectFile)) {
+      files.push({ filePath: projectFile, content: fs.readFileSync(projectFile, 'utf-8'), scope: 'project' });
+    }
+
+    // Discover settings and rules from Cline extension storage
+    if (fs.existsSync(clineDir)) {
+      const scanDir = (dir, scope) => {
+        try {
+          const entries = fs.readdirSync(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const filePath = path.join(dir, entry.name);
+            if (entry.isFile()) {
+              files.push({ filePath, content: fs.readFileSync(filePath, 'utf-8'), scope });
+            } else if (entry.isDirectory()) {
+              scanDir(filePath, scope);
+            }
+          }
+        } catch {}
+      };
+
+      const settingsDir = path.join(clineDir, 'settings');
+      if (fs.existsSync(settingsDir)) {
+        scanDir(settingsDir, 'user');
+      }
+
+      const rulesDir = path.join(clineDir, 'rules');
+      if (fs.existsSync(rulesDir)) {
+        scanDir(rulesDir, 'user');
+      }
+
+      // Discover .md files in root
+      try {
+        const entries = fs.readdirSync(clineDir);
+        for (const entry of entries) {
+          if (entry.endsWith('.md')) {
+            const filePath = path.join(clineDir, entry);
+            if (fs.statSync(filePath).isFile()) {
+              files.push({ filePath, content: fs.readFileSync(filePath, 'utf-8'), scope: 'user' });
+            }
+          }
+        }
+      } catch {}
+    }
+
+    return files;
+  },
+
+  targetPath() {
+    return path.join(cwd, '.clinerules');
+  }
+};

package/src/tools/continuedev.js

@@ -0,0 +1,55 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const home = os.homedir();
+const cwd = process.cwd();
+
+export default {
+  key: 'continuedev',
+  name: 'Continue.dev',
+  icon: '🔄',
+  format: 'JSON, TypeScript, or YAML configuration for Continue.dev AI assistant. Includes config files for model selection, context providers, and slash commands. Supports .continuerules for project-specific instructions.',
+
+  discover() {
+    const files = [];
+    const continueDir = process.platform === 'win32'
+      ? path.join(process.env.USERPROFILE || home, '.continue')
+      : path.join(home, '.continue');
+
+    // Check for .continuerules in project
+    const projectFile = path.join(cwd, '.continuerules');
+    if (fs.existsSync(projectFile)) {
+      files.push({ filePath: projectFile, content: fs.readFileSync(projectFile, 'utf-8'), scope: 'project' });
+    }
+
+    if (fs.existsSync(continueDir)) {
+      const configFiles = ['config.json', 'config.ts', 'config.yaml', '.continuerules'];
+      for (const file of configFiles) {
+        const filePath = path.join(continueDir, file);
+        if (fs.existsSync(filePath)) {
+          files.push({ filePath, content: fs.readFileSync(filePath, 'utf-8'), scope: 'user' });
+        }
+      }
+
+      // Discover .md files in root
+      try {
+        const entries = fs.readdirSync(continueDir);
+        for (const entry of entries) {
+          if (entry.endsWith('.md')) {
+            const filePath = path.join(continueDir, entry);
+            if (fs.statSync(filePath).isFile()) {
+              files.push({ filePath, content: fs.readFileSync(filePath, 'utf-8'), scope: 'user' });
+            }
+          }
+        }
+      } catch {}
+    }
+
+    return files;
+  },
+
+  targetPath() {
+    return path.join(cwd, '.continuerules');
+  }
+};

package/src/tools/index.js

@@ -4,10 +4,13 @@ import codex from './codex.js';
 import cursor from './cursor.js';
 import copilot from './copilot.js';
 import windsurf from './windsurf.js';
+import zed from './zed.js';
+import cline from './cline.js';
+import continuedev from './continuedev.js';
 import aider from './aider.js';
 
 const registry = {};
-for (const tool of [claude, gemini, codex, cursor, copilot, windsurf, aider]) {
+for (const tool of [claude, gemini, codex, cursor, copilot, windsurf, zed, cline, continuedev, aider]) {
   registry[tool.key] = tool;
 }
 

package/src/tools/zed.js

@@ -0,0 +1,50 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const home = os.homedir();
+const cwd = process.cwd();
+
+export default {
+  key: 'zed',
+  name: 'Zed',
+  icon: '🔶',
+  format: 'JSON or markdown configuration files for Zed editor. Includes settings.json for editor preferences, keymap.json for keybindings, and tasks.json for task runner configs.',
+
+  discover() {
+    const files = [];
+    const zedDir = process.platform === 'win32'
+      ? path.join(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'Zed')
+      : path.join(home, '.config', 'zed');
+
+    if (fs.existsSync(zedDir)) {
+      const configFiles = ['settings.json', 'keymap.json', 'tasks.json'];
+      for (const file of configFiles) {
+        const filePath = path.join(zedDir, file);
+        if (fs.existsSync(filePath)) {
+          files.push({ filePath, content: fs.readFileSync(filePath, 'utf-8'), scope: 'user' });
+        }
+      }
+      // Also discover .md files in root
+      try {
+        const entries = fs.readdirSync(zedDir);
+        for (const entry of entries) {
+          if (entry.endsWith('.md')) {
+            const filePath = path.join(zedDir, entry);
+            if (fs.statSync(filePath).isFile()) {
+              files.push({ filePath, content: fs.readFileSync(filePath, 'utf-8'), scope: 'user' });
+            }
+          }
+        }
+      } catch {}
+    }
+    return files;
+  },
+
+  targetPath() {
+    const zedDir = process.platform === 'win32'
+      ? path.join(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'Zed')
+      : path.join(home, '.config', 'zed');
+    return path.join(zedDir, 'settings.json');
+  }
+};