memoir-cli 2.1.1 → 2.4.0

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(options = {}) {
+  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(options.profile);
+  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/profile.js

@@ -0,0 +1,199 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+import inquirer from 'inquirer';
+import { execFileSync } from 'child_process';
+import {
+  getRawConfig, listProfiles, getActiveProfileName,
+  createProfile, switchProfile, deleteProfile
+} from '../config.js';
+
+function getGitHubUsername() {
+  try {
+    return execFileSync('gh', ['api', 'user', '--jq', '.login'], { encoding: 'utf8' }).trim();
+  } catch {
+    try {
+      return execFileSync('git', ['config', '--global', 'user.name'], { encoding: 'utf8' }).trim();
+    } catch { return ''; }
+  }
+}
+
+export async function profileListCommand() {
+  const profiles = await listProfiles();
+  const active = await getActiveProfileName();
+  const raw = await getRawConfig();
+
+  if (profiles.length === 0) {
+    console.log('\n' + chalk.yellow('No profiles configured. Run ') + chalk.cyan('memoir init') + chalk.yellow(' first.\n'));
+    return;
+  }
+
+  console.log();
+  console.log(chalk.bold.white('  Profiles:\n'));
+
+  for (const name of profiles) {
+    const isActive = name === active;
+    const marker = isActive ? chalk.green(' ✔ ') : chalk.gray('   ');
+    const label = isActive ? chalk.white.bold(name) : chalk.white(name);
+
+    // Get profile details
+    let detail = '';
+    if (raw.version >= 2 && raw.profiles?.[name]) {
+      const p = raw.profiles[name];
+      const dest = p.provider === 'git' ? p.gitRepo : p.localPath;
+      detail = chalk.gray(` → ${dest}`);
+      if (p.only) detail += chalk.gray(` (${p.only.join(', ')})`);
+    } else if (!raw.version) {
+      const dest = raw.provider === 'git' ? raw.gitRepo : raw.localPath;
+      detail = chalk.gray(` → ${dest}`);
+    }
+
+    console.log(`${marker}${label}${detail}`);
+  }
+  console.log();
+}
+
+export async function profileCreateCommand(name) {
+  const profiles = await listProfiles();
+  if (profiles.includes(name)) {
+    console.log(chalk.red(`\n✖ Profile "${name}" already exists.\n`));
+    return;
+  }
+
+  console.log('\n' + chalk.cyan(`Creating profile: ${chalk.bold(name)}\n`));
+
+  const detectedUser = getGitHubUsername();
+
+  const { provider } = await inquirer.prompt([{
+    type: 'list',
+    name: 'provider',
+    message: 'Storage for this profile?',
+    choices: [
+      { name: 'GitHub', value: 'git' },
+      { name: 'Local folder', value: 'local' }
+    ]
+  }]);
+
+  const profileConfig = { provider };
+
+  if (provider === 'local') {
+    const { localPath } = await inquirer.prompt([{
+      type: 'input',
+      name: 'localPath',
+      message: 'Save to:',
+      validate: (input) => input.trim() ? true : 'Required'
+    }]);
+    profileConfig.localPath = localPath;
+  } else {
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'username',
+        message: 'GitHub username:',
+        default: detectedUser || undefined,
+        validate: (input) => input.trim() ? true : 'Required'
+      },
+      {
+        type: 'input',
+        name: 'repo',
+        message: 'Repo name:',
+        default: `ai-memory-${name}`,
+        validate: (input) => input.trim() ? true : 'Required'
+      }
+    ]);
+    const username = answers.username.trim();
+    const repo = answers.repo.trim();
+    profileConfig.gitRepo = `https://github.com/${username}/${repo}.git`;
+
+    // Auto-create repo if possible
+    try {
+      execFileSync('gh', ['repo', 'view', `${username}/${repo}`], { stdio: 'ignore' });
+      console.log(chalk.gray(`  ✔ Repo exists`));
+    } catch {
+      try {
+        execFileSync('gh', ['repo', 'create', `${username}/${repo}`, '--private', '--description', `AI memory backup - ${name} (memoir-cli)`], { stdio: 'ignore' });
+        console.log(chalk.green(`  ✔ Created private repo`));
+      } catch {
+        console.log(chalk.yellow(`  ⚠ Could not auto-create repo. Create it manually on GitHub.`));
+      }
+    }
+  }
+
+  // Ask which tools to sync (optional filter)
+  const { filterTools } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'filterTools',
+    message: 'Limit this profile to specific tools?',
+    default: false
+  }]);
+
+  if (filterTools) {
+    const { tools } = await inquirer.prompt([{
+      type: 'checkbox',
+      name: 'tools',
+      message: 'Which tools should this profile sync?',
+      choices: [
+        { name: 'Claude Code', value: 'claude' },
+        { name: 'Gemini CLI', value: 'gemini' },
+        { name: 'OpenAI Codex', value: 'codex' },
+        { name: 'Cursor', value: 'cursor' },
+        { name: 'GitHub Copilot', value: 'copilot' },
+        { name: 'Windsurf', value: 'windsurf' },
+        { name: 'Zed', value: 'zed' },
+        { name: 'Cline', value: 'cline' },
+        { name: 'Continue.dev', value: 'continue' },
+        { name: 'Aider', value: 'aider' }
+      ]
+    }]);
+    if (tools.length > 0) {
+      profileConfig.only = tools;
+    }
+  }
+
+  await createProfile(name, profileConfig);
+
+  // Ask if they want to switch to it
+  const { switchNow } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'switchNow',
+    message: `Switch to "${name}" now?`,
+    default: true
+  }]);
+
+  if (switchNow) {
+    await switchProfile(name);
+  }
+
+  console.log('\n' + boxen(
+    chalk.green(`✔ Profile "${name}" created`) +
+    (switchNow ? chalk.gray(` (now active)`) : ''),
+    { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'green', dimBorder: true }
+  ) + '\n');
+}
+
+export async function profileSwitchCommand(name) {
+  try {
+    await switchProfile(name);
+    console.log('\n' + chalk.green(`✔ Switched to profile "${name}"\n`));
+  } catch (err) {
+    console.log('\n' + chalk.red(`✖ ${err.message}\n`));
+  }
+}
+
+export async function profileDeleteCommand(name) {
+  try {
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: `Delete profile "${name}"? This cannot be undone.`,
+      default: false
+    }]);
+    if (!confirm) {
+      console.log(chalk.gray('\nCancelled.\n'));
+      return;
+    }
+    await deleteProfile(name);
+    console.log('\n' + chalk.green(`✔ Profile "${name}" deleted\n`));
+  } catch (err) {
+    console.log('\n' + chalk.red(`✖ ${err.message}\n`));
+  }
+}

package/src/commands/push.js

@@ -10,7 +10,7 @@ import { extractMemories, adapters } from '../adapters/index.js';
 import { syncToLocal, syncToGit } from '../providers/index.js';
 
 export async function pushCommand(options = {}) {
-  const config = await getConfig();
+  const config = await getConfig(options.profile);
 
   if (!config) {
     console.log('\n' + boxen(
@@ -28,7 +28,9 @@ export async function pushCommand(options = {}) {
   await fs.ensureDir(stagingDir);
 
   try {
-    const onlyFilter = options.only ? options.only.split(',').map(t => t.trim().toLowerCase()) : null;
+    // Profile-level tool filter (config.only) merged with CLI --only flag
+    const onlyRaw = options.only || (config.only ? config.only.join(',') : null);
+    const onlyFilter = onlyRaw ? onlyRaw.split(',').map(t => t.trim().toLowerCase()) : null;
     const foundAny = await extractMemories(stagingDir, spinner, onlyFilter);
 
     if (!foundAny) {

package/src/commands/restore.js

@@ -9,7 +9,7 @@ import { getConfig } from '../config.js';
 import { fetchFromLocal, fetchFromGit } from '../providers/restore.js';
 
 export async function restoreCommand(options = {}) {
-  const config = await getConfig();
+  const config = await getConfig(options.profile);
 
   if (!config) {
     console.log('\n' + boxen(

package/src/commands/resume.js

@@ -92,7 +92,7 @@ async function injectHandoff(content, tool) {
 }
 
 export async function resumeCommand(options = {}) {
-  const config = await getConfig();
+  const config = await getConfig(options.profile);
 
   if (!config) {
     console.log('\n' + boxen(

package/src/commands/snapshot.js

@@ -264,7 +264,7 @@ Keep it under 300 words total. Be specific about file names and features.`;
 }
 
 export async function snapshotCommand(options = {}) {
-  const config = await getConfig();
+  const config = await getConfig(options.profile);
 
   console.log();
   const spinner = ora({ text: chalk.gray('Finding latest session...'), spinner: 'dots' }).start();

package/src/commands/status.js

@@ -6,8 +6,8 @@ import gradient from 'gradient-string';
 import { getConfig } from '../config.js';
 import { adapters } from '../adapters/index.js';
 
-export async function statusCommand() {
-  const config = await getConfig();
+export async function statusCommand(options = {}) {
+  const config = await getConfig(options.profile);
 
   console.log();
 
@@ -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/commands/view.js

@@ -36,8 +36,8 @@ function isBinaryFile(filePath) {
   return binaryExts.includes(path.extname(filePath).toLowerCase());
 }
 
-export async function viewCommand() {
-  const config = await getConfig();
+export async function viewCommand(options = {}) {
+  const config = await getConfig(options.profile);
   if (!config) {
     console.log(chalk.red('\n✖ Not configured yet. Run: memoir init\n'));
     return;