memoir-cli 2.2.0 → 2.5.0

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();
 

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;

package/src/config.js

@@ -7,7 +7,8 @@ const CONFIG_DIR = process.platform === 'win32'
   : path.join(os.homedir(), '.config', 'memoir');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 
-export async function getConfig() {
+// Read the raw config file as-is
+export async function getRawConfig() {
   if (await fs.pathExists(CONFIG_FILE)) {
     try {
       return await fs.readJson(CONFIG_FILE);
@@ -18,22 +19,108 @@ export async function getConfig() {
   return null;
 }
 
+// Get resolved config for a specific profile (or active profile)
+// Backwards compatible: v1 flat configs return as-is
+export async function getConfig(profileName = null) {
+  const raw = await getRawConfig();
+  if (!raw) return null;
+
+  // v1 flat config — no profiles, return as-is
+  if (!raw.version || raw.version < 2) return raw;
+
+  // v2 — resolve profile
+  const name = profileName || raw.activeProfile || 'default';
+  const profile = raw.profiles?.[name];
+  if (!profile) return null;
+
+  // Merge top-level shared keys into profile
+  return { ...profile, geminiApiKey: raw.geminiApiKey };
+}
+
+// Save entire raw config
 export async function saveConfig(config) {
   await fs.ensureDir(CONFIG_DIR);
   await fs.writeJson(CONFIG_FILE, config, { spaces: 2 });
-  // Restrict permissions — config may contain API keys
   if (process.platform !== 'win32') {
     await fs.chmod(CONFIG_FILE, 0o600);
   }
 }
 
+// Save config for a specific profile (creates v2 format if needed)
+export async function saveProfileConfig(profileName, profileData) {
+  let raw = await getRawConfig() || {};
+  if (!raw.version || raw.version < 2) {
+    raw = migrateConfigToV2(raw);
+  }
+  raw.profiles[profileName] = profileData;
+  await saveConfig(raw);
+}
+
+// Migrate v1 flat config to v2 profiles format
+export function migrateConfigToV2(flat) {
+  const { provider, gitRepo, localPath, geminiApiKey, ...rest } = flat;
+  return {
+    version: 2,
+    activeProfile: 'default',
+    geminiApiKey: geminiApiKey || undefined,
+    profiles: {
+      default: { provider, gitRepo, localPath, ...rest }
+    }
+  };
+}
+
+export async function getActiveProfileName() {
+  const raw = await getRawConfig();
+  if (!raw || !raw.version || raw.version < 2) return 'default';
+  return raw.activeProfile || 'default';
+}
+
+export async function listProfiles() {
+  const raw = await getRawConfig();
+  if (!raw) return [];
+  if (!raw.version || raw.version < 2) return ['default'];
+  return Object.keys(raw.profiles || {});
+}
+
+export async function createProfile(name, profileConfig) {
+  let raw = await getRawConfig() || {};
+  if (!raw.version || raw.version < 2) {
+    raw = migrateConfigToV2(raw);
+  }
+  raw.profiles[name] = profileConfig;
+  await saveConfig(raw);
+}
+
+export async function switchProfile(name) {
+  let raw = await getRawConfig();
+  if (!raw) throw new Error('Not configured. Run memoir init first.');
+  if (!raw.version || raw.version < 2) {
+    raw = migrateConfigToV2(raw);
+  }
+  if (!raw.profiles[name]) throw new Error(`Profile "${name}" does not exist.`);
+  raw.activeProfile = name;
+  await saveConfig(raw);
+}
+
+export async function deleteProfile(name) {
+  const raw = await getRawConfig();
+  if (!raw || !raw.version || raw.version < 2) {
+    throw new Error('No profiles configured.');
+  }
+  if (!raw.profiles[name]) throw new Error(`Profile "${name}" does not exist.`);
+  if (raw.activeProfile === name) throw new Error(`Cannot delete the active profile. Switch first with: memoir profile switch <name>`);
+  if (Object.keys(raw.profiles).length <= 1) throw new Error('Cannot delete the last profile.');
+  delete raw.profiles[name];
+  await saveConfig(raw);
+}
+
 export async function getGeminiApiKey() {
-  const config = await getConfig();
-  return config?.geminiApiKey || process.env.GEMINI_API_KEY || null;
+  const raw = await getRawConfig();
+  return raw?.geminiApiKey || process.env.GEMINI_API_KEY || null;
 }
 
 export async function saveGeminiApiKey(apiKey) {
-  const config = await getConfig() || {};
-  config.geminiApiKey = apiKey;
-  await saveConfig(config);
+  let raw = await getRawConfig() || {};
+  raw.geminiApiKey = apiKey;
+  await saveConfig(raw);
 }

package/src/tools/chatgpt.js

@@ -0,0 +1,24 @@
+import fs from 'fs';
+import path from 'path';
+
+const cwd = process.cwd();
+
+export default {
+  key: 'chatgpt',
+  name: 'ChatGPT',
+  icon: '💬',
+  format: 'Markdown custom instructions in CHATGPT.md. Written as instructions for ChatGPT — your preferences, coding style, response format, and project context. Paste into ChatGPT\'s Custom Instructions or Memory settings.',
+
+  discover() {
+    const files = [];
+    const projectFile = path.join(cwd, 'CHATGPT.md');
+    if (fs.existsSync(projectFile)) {
+      files.push({ filePath: projectFile, content: fs.readFileSync(projectFile, 'utf-8'), scope: 'project' });
+    }
+    return files;
+  },
+
+  targetPath() {
+    return path.join(cwd, 'CHATGPT.md');
+  }
+};

package/src/tools/index.js

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