memoir-cli 3.1.1 → 3.2.0

package/src/commands/upgrade.js

@@ -0,0 +1,107 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+import gradient from 'gradient-string';
+import { getSession, getSubscription } from '../cloud/auth.js';
+
+export async function upgradeCommand() {
+  const session = await getSession();
+  let currentPlan = 'free';
+  let email = null;
+
+  if (session) {
+    email = session.user.email;
+    try {
+      const sub = await getSubscription(session);
+      currentPlan = sub.status === 'pro' ? 'pro' : 'free';
+    } catch {
+      // Fall through as free
+    }
+  }
+
+  // Build comparison table
+  const col1 = 22;
+  const col2 = 22;
+
+  const pad = (str, width) => {
+    // Strip ANSI for length calculation
+    const stripped = str.replace(/\u001b\[[0-9;]*m/g, '');
+    const diff = width - stripped.length;
+    return diff > 0 ? str + ' '.repeat(diff) : str;
+  };
+
+  const freeLabel = currentPlan === 'free' ? 'Free (current)' : 'Free';
+  const proLabel = currentPlan === 'pro' ? 'Pro (current)' : 'Pro $15/mo';
+  const teamsLabel = 'Teams $29/seat';
+
+  const header =
+    pad(chalk.bold.white(freeLabel), col1) +
+    pad(chalk.bold.cyan(proLabel), col2) +
+    chalk.bold.magenta(teamsLabel);
+
+  const sep = chalk.gray('─'.repeat(col1 + col2 + 18));
+
+  const rows = [
+    [chalk.gray('3 cloud backups'),   chalk.white('50 cloud backups'),   chalk.white('Unlimited backups')],
+    [chalk.gray('Local only'),        chalk.white('Unlimited machines'), chalk.white('Shared team context')],
+    [chalk.gray('Manual snapshots'),  chalk.white('Auto snapshots'),     chalk.white('Team dashboard')],
+    [chalk.gray('Community support'), chalk.white('Priority support'),   chalk.white('Audit log')],
+    [chalk.gray('—'),                 chalk.white('E2E encryption'),     chalk.white('SSO & RBAC')],
+    [chalk.gray('—'),                 chalk.white('Version history'),    chalk.white('Priority onboarding')],
+  ];
+
+  const tableRows = rows.map(([a, b, c]) =>
+    pad(a, col1) + pad(b, col2) + c
+  ).join('\n');
+
+  const table =
+    '\n' + header + '\n' +
+    sep + '\n' +
+    tableRows + '\n';
+
+  // Status line
+  let statusLine;
+  if (!session) {
+    statusLine = chalk.yellow('Not logged in.') + chalk.gray(' Run ') + chalk.cyan('memoir login') + chalk.gray(' first.');
+  } else if (currentPlan === 'pro') {
+    statusLine = chalk.green('You\'re on Pro!') + ' ' + chalk.gray('Teams is coming soon — join the waitlist at memoir.sh/teams');
+  } else {
+    statusLine = chalk.gray('Logged in as ') + chalk.cyan(email);
+  }
+
+  console.log('\n' + boxen(
+    gradient.pastel('  memoir upgrade  ') + '\n\n' +
+    table + '\n' +
+    statusLine,
+    { padding: 1, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
+  ));
+
+  // If free and logged in, open pricing page
+  if (session && currentPlan === 'free') {
+    console.log('\n' + chalk.cyan('  Opening pricing page...') + '\n');
+
+    const { exec } = await import('child_process');
+    const url = 'https://memoir.sh/pricing';
+
+    const platform = process.platform;
+    let cmd;
+    if (platform === 'darwin') {
+      cmd = `open "${url}"`;
+    } else if (platform === 'win32') {
+      cmd = `start "${url}"`;
+    } else {
+      cmd = `xdg-open "${url}"`;
+    }
+
+    exec(cmd, () => {});
+
+    console.log(
+      chalk.gray('  Once you\'ve completed payment, run ') +
+      chalk.cyan('memoir login') +
+      chalk.gray(' to refresh your plan.') + '\n'
+    );
+  } else if (!session) {
+    console.log('\n' + chalk.gray('  Sign up at ') + chalk.cyan('memoir.sh/pricing') + chalk.gray(' or run ') + chalk.cyan('memoir login') + chalk.gray(' to get started.') + '\n');
+  } else {
+    console.log();
+  }
+}

package/src/context/capture.js

@@ -287,6 +287,83 @@ ${section}`;
   return fresh.length;
 }
 
+/**
+ * Promote memories from project-scoped dirs to the home-level scope.
+ * Claude scopes memory per working directory — memories saved in ~/memoir
+ * are invisible from ~/btc-trader. This copies important .md files to the
+ * home-level scope so they're accessible from ANY directory.
+ *
+ * Only promotes files with frontmatter type: user or type: project (not ephemeral ones).
+ */
+export function promoteMemoriesToGlobal() {
+  const claudeDir = path.join(home, '.claude');
+  const projectsDir = path.join(claudeDir, 'projects');
+  if (!fs.existsSync(projectsDir)) return 0;
+
+  // Find the home-level key
+  let homeKey;
+  if (process.platform === 'win32') {
+    homeKey = home.replace(/\\/g, '-').replace(/:/g, '-');
+  } else {
+    homeKey = '-' + home.replace(/^\//, '').replace(/\//g, '-');
+  }
+
+  const homeMemDir = path.join(projectsDir, homeKey, 'memory');
+  fs.mkdirSync(homeMemDir, { recursive: true });
+
+  const homeMemoryMdPath = path.join(homeMemDir, 'MEMORY.md');
+  let homeMemoryMd = '';
+  if (fs.existsSync(homeMemoryMdPath)) {
+    homeMemoryMd = fs.readFileSync(homeMemoryMdPath, 'utf8');
+  } else {
+    homeMemoryMd = '# Project Memory\n';
+  }
+
+  let promoted = 0;
+  const entries = fs.readdirSync(projectsDir, { withFileTypes: true })
+    .filter(e => e.isDirectory() && e.name !== homeKey);
+
+  for (const entry of entries) {
+    const memDir = path.join(projectsDir, entry.name, 'memory');
+    if (!fs.existsSync(memDir)) continue;
+
+    const files = fs.readdirSync(memDir)
+      .filter(f => f.endsWith('.md') && f !== 'MEMORY.md' && f !== 'handoff.md');
+
+    for (const file of files) {
+      const destPath = path.join(homeMemDir, file);
+      // Skip if already exists in home scope
+      if (fs.existsSync(destPath)) continue;
+
+      const content = fs.readFileSync(path.join(memDir, file), 'utf8');
+
+      // Only promote files with type: user or type: project
+      const typeMatch = content.match(/^type:\s*(user|project)/m);
+      if (!typeMatch) continue;
+
+      // Copy to home scope
+      fs.writeFileSync(destPath, content);
+
+      // Add to MEMORY.md if not already referenced
+      if (!homeMemoryMd.includes(file)) {
+        const nameMatch = content.match(/^name:\s*(.+)/m);
+        const descMatch = content.match(/^description:\s*(.+)/m);
+        const name = nameMatch ? nameMatch[1].trim() : file.replace('.md', '').replace(/-/g, ' ');
+        const desc = descMatch ? descMatch[1].trim() : '';
+        homeMemoryMd += `- [${name}](${file})${desc ? ' — ' + desc : ''}\n`;
+      }
+
+      promoted++;
+    }
+  }
+
+  if (promoted > 0) {
+    fs.writeFileSync(homeMemoryMdPath, homeMemoryMd);
+  }
+
+  return promoted;
+}
+
 /**
  * Generate a concise handoff markdown from parsed session
  * This is what gets injected into the AI tool on the other machine

package/src/mcp.js

@@ -0,0 +1,429 @@
+#!/usr/bin/env node
+/**
+ * Memoir MCP Server
+ *
+ * Exposes memoir's memory management as MCP tools for Claude Code, Cursor, VS Code, etc.
+ * Run via: memoir mcp (or directly: node src/mcp.js)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { z } from 'zod';
+import { getConfig, listProfiles, getActiveProfileName } from './config.js';
+import { adapters } from './adapters/index.js';
+
+const home = os.homedir();
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+/**
+ * Read all memory files from a tool adapter's source directory
+ */
+async function readMemoryFiles(adapter) {
+  const files = [];
+
+  if (adapter.customExtract) {
+    for (const file of adapter.files) {
+      const filePath = path.join(adapter.source, file);
+      if (await fs.pathExists(filePath)) {
+        try {
+          const content = await fs.readFile(filePath, 'utf8');
+          files.push({ path: file, content, tool: adapter.name });
+        } catch {}
+      }
+    }
+    return files;
+  }
+
+  if (!(await fs.pathExists(adapter.source))) return files;
+
+  const walk = async (dir, prefix = '') => {
+    let entries;
+    try { entries = await fs.readdir(dir, { withFileTypes: true }); } catch { return; }
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+
+      if (entry.isDirectory()) {
+        if (adapter.filter(fullPath)) {
+          await walk(fullPath, relPath);
+        }
+      } else if (entry.name.endsWith('.md') || entry.name.endsWith('.json') || entry.name.endsWith('.yml') || entry.name.endsWith('.yaml')) {
+        if (adapter.filter(fullPath)) {
+          try {
+            const content = await fs.readFile(fullPath, 'utf8');
+            files.push({ path: relPath, content, tool: adapter.name });
+          } catch {}
+        }
+      }
+    }
+  };
+
+  await walk(adapter.source);
+  return files;
+}
+
+/**
+ * Search across all memory files for a query (case-insensitive keyword match)
+ */
+async function searchMemories(query) {
+  const results = [];
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+
+  for (const adapter of adapters) {
+    const files = await readMemoryFiles(adapter);
+    for (const file of files) {
+      const lower = file.content.toLowerCase();
+      const score = terms.reduce((s, t) => s + (lower.includes(t) ? 1 : 0), 0);
+      if (score > 0) {
+        results.push({ ...file, score, relevance: score / terms.length });
+      }
+    }
+  }
+
+  // Also search per-project AI config files
+  const projectFiles = ['CLAUDE.md', 'GEMINI.md', 'CHATGPT.md', '.cursorrules', '.windsurfrules', '.clinerules'];
+  const skipDirs = new Set(['node_modules', '.git', '.next', '.vercel', 'dist', 'build', '__pycache__', '.venv', 'venv', '.cache', 'Library', '.Trash', 'Applications', 'Downloads']);
+
+  const scanProjects = async (dir, depth = 0) => {
+    if (depth > 3) return;
+    let entries;
+    try { entries = await fs.readdir(dir, { withFileTypes: true }); } catch { return; }
+
+    for (const file of projectFiles) {
+      const filePath = path.join(dir, file);
+      if (await fs.pathExists(filePath)) {
+        try {
+          const content = await fs.readFile(filePath, 'utf8');
+          const lower = content.toLowerCase();
+          const score = terms.reduce((s, t) => s + (lower.includes(t) ? 1 : 0), 0);
+          if (score > 0) {
+            results.push({
+              path: `${path.basename(dir)}/${file}`,
+              content,
+              tool: `Project: ${path.basename(dir)}`,
+              score,
+              relevance: score / terms.length
+            });
+          }
+        } catch {}
+      }
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.') && entry.name !== '.github') continue;
+      if (skipDirs.has(entry.name)) continue;
+      await scanProjects(path.join(dir, entry.name), depth + 1);
+    }
+  };
+
+  await scanProjects(home);
+
+  return results.sort((a, b) => b.score - a.score);
+}
+
+/**
+ * Get list of detected tools with status
+ */
+async function getDetectedTools() {
+  const detected = [];
+  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);
+    }
+    detected.push({ name: adapter.name, icon: adapter.icon, installed: found });
+  }
+  return detected;
+}
+
+// ── MCP Server ───────────────────────────────────────────────────────────────
+
+const server = new McpServer({
+  name: 'memoir',
+  version: '3.2.0',
+}, {
+  capabilities: {
+    tools: {},
+    resources: {},
+  }
+});
+
+// ── Tools ────────────────────────────────────────────────────────────────────
+
+server.tool(
+  'memoir_status',
+  'Show which AI tools are detected on this machine and memoir configuration status',
+  {},
+  async () => {
+    const config = await getConfig();
+    const tools = await getDetectedTools();
+    const profile = await getActiveProfileName();
+    const profiles = await listProfiles();
+
+    const installed = tools.filter(t => t.installed);
+    const toolList = installed.map(t => `  ${t.icon} ${t.name}`).join('\n');
+    const notInstalled = tools.filter(t => !t.installed).map(t => t.name).join(', ');
+
+    let configStatus;
+    if (config) {
+      const dest = config.provider === 'git' ? config.gitRepo : config.localPath;
+      configStatus = `Connected → ${dest}`;
+    } else {
+      configStatus = 'Not configured (run: memoir init)';
+    }
+
+    return {
+      content: [{
+        type: 'text',
+        text: [
+          `Memoir Status`,
+          `─────────────`,
+          `Config: ${configStatus}`,
+          `Profile: ${profile} (${profiles.length} total)`,
+          `Encryption: ${config?.encrypt ? 'enabled' : 'disabled'}`,
+          ``,
+          `Detected AI Tools (${installed.length}):`,
+          toolList,
+          ``,
+          notInstalled.length > 0 ? `Also supports: ${notInstalled}` : '',
+        ].filter(Boolean).join('\n')
+      }]
+    };
+  }
+);
+
+server.tool(
+  'memoir_recall',
+  'Search across all AI tool memories, project configs, and session context for relevant information. Use this to find what you know about a topic, project, or tool.',
+  { query: z.string().describe('Search query — keywords or topic to find in memories') },
+  async ({ query }) => {
+    const results = await searchMemories(query);
+
+    if (results.length === 0) {
+      return {
+        content: [{ type: 'text', text: `No memories found matching "${query}".` }]
+      };
+    }
+
+    // Return top 10 results with content
+    const top = results.slice(0, 10);
+    const output = top.map((r, i) => {
+      const preview = r.content.length > 500 ? r.content.slice(0, 500) + '...' : r.content;
+      return [
+        `── ${i + 1}. ${r.tool} / ${r.path} (relevance: ${Math.round(r.relevance * 100)}%) ──`,
+        preview,
+      ].join('\n');
+    }).join('\n\n');
+
+    return {
+      content: [{
+        type: 'text',
+        text: `Found ${results.length} memories matching "${query}":\n\n${output}`
+      }]
+    };
+  }
+);
+
+server.tool(
+  'memoir_remember',
+  'Save a memory to a specific AI tool\'s memory files. Use this to persist important context, decisions, or facts for future sessions.',
+  {
+    content: z.string().describe('The memory content to save (markdown format)'),
+    filename: z.string().describe('Filename for the memory (e.g. "auth-setup.md", "project-goals.md")'),
+    tool: z.string().optional().describe('Which AI tool to save to: "claude", "gemini", "cursor", etc. Defaults to claude.'),
+    project: z.string().optional().describe('Project directory path to save a project-level memory (e.g. CLAUDE.md). If provided, saves to that project directory instead of global tool config.'),
+  },
+  async ({ content, filename, tool, project }) => {
+    // Project-level memory
+    if (project) {
+      const projectDir = project.startsWith('/') ? project : path.join(home, project);
+      if (!(await fs.pathExists(projectDir))) {
+        return { content: [{ type: 'text', text: `Project directory not found: ${projectDir}` }] };
+      }
+
+      // Default to CLAUDE.md for project-level memories
+      const targetFile = filename || 'CLAUDE.md';
+      const targetPath = path.join(projectDir, targetFile);
+
+      // Append to existing file or create new
+      if (await fs.pathExists(targetPath)) {
+        const existing = await fs.readFile(targetPath, 'utf8');
+        await fs.writeFile(targetPath, existing + '\n\n' + content);
+      } else {
+        await fs.writeFile(targetPath, content);
+      }
+
+      return {
+        content: [{ type: 'text', text: `Saved to ${targetPath}` }]
+      };
+    }
+
+    // Global tool memory
+    const toolKey = (tool || 'claude').toLowerCase();
+
+    // Find the right directory for the tool
+    let targetDir;
+    if (toolKey === 'claude') {
+      // Save to Claude's memory system
+      const claudeMemDir = path.join(home, '.claude', 'projects', '-Users-' + path.basename(home), 'memory');
+      await fs.ensureDir(claudeMemDir);
+      targetDir = claudeMemDir;
+    } else if (toolKey === 'gemini') {
+      targetDir = path.join(home, '.gemini');
+    } else if (toolKey === 'cursor') {
+      const cursorDir = process.platform === 'win32'
+        ? path.join(process.env.APPDATA || '', 'Cursor', 'User', 'rules')
+        : path.join(home, 'Library', 'Application Support', 'Cursor', 'User', 'rules');
+      await fs.ensureDir(cursorDir);
+      targetDir = cursorDir;
+    } else {
+      return { content: [{ type: 'text', text: `Unsupported tool for writing: ${toolKey}. Supported: claude, gemini, cursor` }] };
+    }
+
+    if (!filename.endsWith('.md')) filename += '.md';
+    const targetPath = path.join(targetDir, filename);
+    await fs.writeFile(targetPath, content);
+
+    return {
+      content: [{ type: 'text', text: `Memory saved to ${targetPath}` }]
+    };
+  }
+);
+
+server.tool(
+  'memoir_list',
+  'List all memory files across all detected AI tools and projects',
+  {
+    tool: z.string().optional().describe('Filter to a specific tool: "claude", "gemini", "cursor", etc. Leave empty for all.'),
+  },
+  async ({ tool }) => {
+    const allFiles = [];
+
+    for (const adapter of adapters) {
+      if (tool) {
+        const key = tool.toLowerCase();
+        if (!adapter.name.toLowerCase().includes(key)) continue;
+      }
+
+      const files = await readMemoryFiles(adapter);
+      for (const f of files) {
+        allFiles.push({ tool: adapter.name, icon: adapter.icon, path: f.path, size: f.content.length });
+      }
+    }
+
+    if (allFiles.length === 0) {
+      return { content: [{ type: 'text', text: tool ? `No memory files found for ${tool}.` : 'No memory files found.' }] };
+    }
+
+    // Group by tool
+    const grouped = {};
+    for (const f of allFiles) {
+      if (!grouped[f.tool]) grouped[f.tool] = [];
+      grouped[f.tool].push(f);
+    }
+
+    const output = Object.entries(grouped).map(([toolName, files]) => {
+      const icon = files[0]?.icon || '';
+      const fileList = files.map(f => {
+        const sizeStr = f.size < 1024 ? `${f.size}B` : `${(f.size / 1024).toFixed(1)}KB`;
+        return `  ${f.path} (${sizeStr})`;
+      }).join('\n');
+      return `${icon} ${toolName} (${files.length} files)\n${fileList}`;
+    }).join('\n\n');
+
+    return {
+      content: [{ type: 'text', text: `Memory files (${allFiles.length} total):\n\n${output}` }]
+    };
+  }
+);
+
+server.tool(
+  'memoir_read',
+  'Read the full content of a specific memory file',
+  {
+    tool: z.string().describe('Tool name: "claude", "gemini", "cursor", etc.'),
+    filepath: z.string().describe('Relative file path within the tool\'s memory directory'),
+  },
+  async ({ tool, filepath }) => {
+    const toolKey = tool.toLowerCase();
+    const adapter = adapters.find(a => a.name.toLowerCase().includes(toolKey));
+
+    if (!adapter) {
+      return { content: [{ type: 'text', text: `Unknown tool: ${tool}. Available: ${adapters.map(a => a.name).join(', ')}` }] };
+    }
+
+    const fullPath = path.join(adapter.source, filepath);
+
+    if (!(await fs.pathExists(fullPath))) {
+      return { content: [{ type: 'text', text: `File not found: ${filepath} in ${adapter.name}` }] };
+    }
+
+    try {
+      const content = await fs.readFile(fullPath, 'utf8');
+      return {
+        content: [{ type: 'text', text: `── ${adapter.name} / ${filepath} ──\n\n${content}` }]
+      };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error reading file: ${err.message}` }] };
+    }
+  }
+);
+
+server.tool(
+  'memoir_profiles',
+  'List and manage memoir profiles (personal, work, etc.)',
+  {},
+  async () => {
+    const profiles = await listProfiles();
+    const active = await getActiveProfileName();
+
+    if (profiles.length === 0) {
+      return { content: [{ type: 'text', text: 'No profiles configured. Run: memoir init' }] };
+    }
+
+    const list = profiles.map(p => `  ${p === active ? '● ' : '  '}${p}${p === active ? ' (active)' : ''}`).join('\n');
+
+    return {
+      content: [{
+        type: 'text',
+        text: `Memoir Profiles:\n\n${list}\n\nSwitch with: memoir profile switch <name>`
+      }]
+    };
+  }
+);
+
+// ── Resources ────────────────────────────────────────────────────────────────
+
+// Expose detected tools as browsable resources
+server.resource(
+  'detected-tools',
+  'memoir://tools',
+  { description: 'List of AI tools detected on this machine', mimeType: 'text/plain' },
+  async () => {
+    const tools = await getDetectedTools();
+    const text = tools.map(t => `${t.icon} ${t.name}: ${t.installed ? 'installed' : 'not found'}`).join('\n');
+    return { contents: [{ uri: 'memoir://tools', text, mimeType: 'text/plain' }] };
+  }
+);
+
+// ── Start ────────────────────────────────────────────────────────────────────
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  process.stderr.write(`Memoir MCP server error: ${err.message}\n`);
+  process.exit(1);
+});

package/src/providers/index.js

@@ -36,7 +36,7 @@ export async function syncToGit(config, stagingDir, spinner) {
 
   try {
     try {
-      execFileSync('git', ['clone', '--depth', '1', repoUrl, '.'], { cwd: gitDir, stdio: 'ignore' });
+      execFileSync('git', ['clone', '--depth', '1', repoUrl, '.'], { cwd: gitDir, stdio: 'ignore', timeout: 60000 });
       const files = await fs.readdir(gitDir);
       for (const f of files) {
         if (f !== '.git') await fs.remove(path.join(gitDir, f));
@@ -48,20 +48,20 @@ export async function syncToGit(config, stagingDir, spinner) {
 
     await fs.copy(stagingDir, gitDir);
 
-    execFileSync('git', ['add', '-A'], { cwd: gitDir, stdio: 'ignore' });
-    execFileSync('git', ['config', 'user.name', 'memoir'], { cwd: gitDir, stdio: 'ignore' });
-    execFileSync('git', ['config', 'user.email', 'bot@memoir.dev'], { cwd: gitDir, stdio: 'ignore' });
+    execFileSync('git', ['add', '-A'], { cwd: gitDir, stdio: 'ignore', timeout: 30000 });
+    execFileSync('git', ['config', 'user.name', 'memoir'], { cwd: gitDir, stdio: 'ignore', timeout: 5000 });
+    execFileSync('git', ['config', 'user.email', 'bot@memoir.dev'], { cwd: gitDir, stdio: 'ignore', timeout: 5000 });
 
     const timestamp = new Date().toISOString().split('T')[0];
     try {
-      execFileSync('git', ['commit', '-m', `memoir backup ${timestamp}`], { cwd: gitDir, stdio: 'ignore' });
+      execFileSync('git', ['commit', '-m', `memoir backup ${timestamp}`], { cwd: gitDir, stdio: 'ignore', timeout: 30000 });
     } catch {
       spinner.succeed(chalk.green('Already up to date! ') + chalk.gray('No changes to push.'));
       return;
     }
 
     spinner.text = `Pushing data to ${chalk.cyan(repoUrl)}...`;
-    execFileSync('git', ['push', repoUrl, 'main'], { cwd: gitDir, stdio: 'ignore' });
+    execFileSync('git', ['push', repoUrl, 'main'], { cwd: gitDir, stdio: 'ignore', timeout: 120000 });
 
     spinner.succeed(chalk.green('Sync complete! ') + chalk.gray('(Uploaded securely to GitHub)'));
   } catch (err) {