@thanhthi2895/luna-ai 2.16.2

package/bin/commands/install.js

@@ -0,0 +1,864 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import inquirer from 'inquirer';
+
+import { symlink, unlink, lstat } from 'fs/promises';
+
+function getCanonicalClaudeDir(rootDir) {
+  return path.join(rootDir, 'agentic', 'claude', '.claude');
+}
+
+function getCanonicalClaudeMd(rootDir) {
+  return path.join(rootDir, 'agentic', 'claude', 'CLAUDE.md');
+}
+
+function getClaudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+}
+
+function getCanonicalAgentsDir(rootDir) {
+  return path.join(rootDir, 'agentic', 'antigravity', '.agents');
+}
+
+/**
+ * Prompt user to select which agents to install.
+ */
+async function agentSelectionPrompt(isUpdate = false, previousAgents = []) {
+  const defaultSelections = previousAgents.length > 0
+    ? previousAgents
+    : ['claude']; // default: claude only
+
+  const answer = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'agents',
+      message: isUpdate
+        ? 'Which agents do you want to install/update?'
+        : 'Which AI agents do you want to install?',
+      choices: [
+        { name: '🤖 Claude (Claude Code / claude-code CLI)', value: 'claude', checked: defaultSelections.includes('claude') },
+        { name: '⚡ OpenCode (opencode CLI)', value: 'opencode', checked: defaultSelections.includes('opencode') },
+        { name: '🪐 Antigravity (Gemini / Antigravity IDE)', value: 'antigravity', checked: defaultSelections.includes('antigravity') },
+      ],
+      validate: (selected) => selected.length > 0 || 'Please select at least one agent',
+    }
+  ]);
+  return answer.agents;
+}
+
+export async function copyOpencode(rootDir, targetDir) {
+  const srcOpencode = path.join(rootDir, 'agentic', 'opencode');
+  if (!await fs.pathExists(srcOpencode)) {
+    console.log('  ⚠️  opencode source not found, skipping');
+    return;
+  }
+  const destOpencode = path.join(targetDir, '.opencode');
+  await fs.copy(srcOpencode, destOpencode, { overwrite: true, dereference: true });
+}
+
+/**
+ * Ensure GEMINI.md is a symlink pointing to CLAUDE.md in target project.
+ */
+export async function ensureGeminiSymlink(targetDir) {
+  const geminiPath = path.join(targetDir, 'GEMINI.md');
+  const claudePath = path.join(targetDir, 'CLAUDE.md');
+
+  // Only create if CLAUDE.md exists
+  if (!await fs.pathExists(claudePath)) return;
+
+  let stat = null;
+  try { stat = await lstat(geminiPath); } catch { /* doesn't exist */ }
+
+  if (stat) {
+    if (stat.isSymbolicLink()) return; // Already a symlink, nothing to do
+    await unlink(geminiPath);          // Delete strange file then recreate
+  }
+
+  await symlink('CLAUDE.md', geminiPath);
+}
+
+/** Skills only for Luna framework development, not copied to user project */
+const DEV_ONLY_SKILLS = ['release'];
+
+/** Check if path belongs to folder that needs to be skipped */
+function shouldSkip(filePath, skipPaths) {
+  const normalized = path.normalize(filePath);
+  return skipPaths.some(skip =>
+    normalized === skip || normalized.startsWith(skip + path.sep)
+  );
+}
+
+/** Copy canonical .claude to target, exclude: ai-cache, dev-only skills, rules (now in .agents) */
+export async function copyClaude(rootDir, targetDir) {
+  const srcClaude = getCanonicalClaudeDir(rootDir);
+  if (!await fs.pathExists(srcClaude)) {
+    throw new Error(`Canonical Claude directory missing: ${srcClaude}`);
+  }
+  const destClaude = path.join(targetDir, '.claude');
+  const skipPaths = [
+    path.join(srcClaude, 'ai-cache'),
+    path.join(srcClaude, 'settings.local.json'),
+    // rules is in .agents/rules, skip symlink to avoid circular copy
+    path.join(srcClaude, 'rules'),
+    ...DEV_ONLY_SKILLS.map(s => path.join(srcClaude, 'skills', s)),
+  ];
+  await fs.copy(srcClaude, destClaude, {
+    dereference: true,
+    filter: (file) => {
+      // 1. Check regular skipPaths
+      if (shouldSkip(file, skipPaths)) return false;
+
+      // 2. Protect project-memory.md: Don't overwrite if exists in target project
+      if (file.endsWith('project-memory.md')) {
+        const relativePath = path.relative(srcClaude, file);
+        const destPath = path.join(destClaude, relativePath);
+        if (fs.pathExistsSync(destPath)) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+  });
+}
+
+/**
+ * Ensure .claude/<folderName> is a symlink pointing to ../.agents/<folderName>.
+ * If it's a real directory → migrate contents to .agents/<folderName> then replace with symlink.
+ * Used for: rules, skills, agents, workflows.
+ */
+export async function ensureAgentsFolderSymlink(targetDir, folderName) {
+  const claudeDest  = path.join(targetDir, '.claude', folderName);
+  const agentsSrc   = path.join(targetDir, '.agents', folderName);
+  await fs.ensureDir(agentsSrc);
+
+  let stat = null;
+  try { stat = await lstat(claudeDest); } catch { /* doesn't exist */ }
+
+  if (stat) {
+    if (stat.isSymbolicLink()) return; // Already a symlink, nothing to do
+    if (stat.isDirectory()) {
+      // Migrate: copy contents to .agents/<folderName> then delete real directory
+      await fs.copy(claudeDest, agentsSrc, { overwrite: false });
+      await fs.remove(claudeDest);
+      console.log(` Migrated .claude/${folderName}/ → .agents/${folderName}/ and created symlink.`);
+    } else {
+      await unlink(claudeDest); // regular file, delete it
+    }
+  }
+
+  await symlink(path.join('..', '.agents', folderName), claudeDest);
+}
+
+/** Alias for backwards compatibility (local install only needs rules) */
+export async function ensureRulesSymlink(targetDir) {
+  return ensureAgentsFolderSymlink(targetDir, 'rules');
+}
+
+/**
+ * Copy agent folders from source .agents/ → ~/.claude/ for global install.
+ * No symlinks — everything is a real copy. Skips broken symlinks and dev-only skills.
+ */
+async function copyAgentsFoldersToClaude(rootDir, claudeHome) {
+  const folders = ['rules', 'skills', 'agents', 'workflows', 'hooks'];
+  const srcAgents = getCanonicalAgentsDir(rootDir);
+  const devSkipPaths = DEV_ONLY_SKILLS.map(s => path.join(srcAgents, 'skills', s));
+  for (const folder of folders) {
+    const src = path.join(srcAgents, folder);
+    const dest = path.join(claudeHome, folder);
+    // Remove existing (old symlink or directory) before copy
+    let st = null;
+    try { st = await lstat(dest); } catch { /* doesn't exist */ }
+    if (st) {
+      if (st.isSymbolicLink()) await unlink(dest);
+      else await fs.remove(dest);
+    }
+    if (!await fs.pathExists(src)) continue;
+    await fs.copy(src, dest, {
+      dereference: true,
+      filter: (file) => {
+        // Skip broken symlinks
+        try {
+          const s = fs.lstatSync(file);
+          if (s.isSymbolicLink()) {
+            try { fs.statSync(file); } catch { return false; }
+          }
+        } catch { return false; }
+        // Skip dev-only skills
+        if (shouldSkip(file, devSkipPaths)) return false;
+        return true;
+      }
+    });
+  }
+}
+
+/**
+ * Copy supporting files from source .agents/ → ~/.claude/ (scripts, templates).
+ */
+async function copyAgentsSupportFiles(rootDir, claudeHome) {
+  const srcAgents = getCanonicalAgentsDir(rootDir);
+  const items = ['scripts', 'templates'];
+  for (const item of items) {
+    const src = path.join(srcAgents, item);
+    if (await fs.pathExists(src)) {
+      await fs.copy(src, path.join(claudeHome, item), { overwrite: true, dereference: true });
+    }
+  }
+}
+
+/** Copy .agents/ to local target project. Skip broken symlinks, dev-only, skills-optional. Protect project-memory.md. */
+export async function copyAgentsLocal(rootDir, targetDir) {
+  const srcAgents = getCanonicalAgentsDir(rootDir);
+  const destAgents = path.join(targetDir, '.agents');
+  const skipPaths = [
+    path.join(srcAgents, 'skills-optional'),
+    ...DEV_ONLY_SKILLS.map(s => path.join(srcAgents, 'skills', s)),
+  ];
+  await fs.copy(srcAgents, destAgents, {
+    dereference: true,
+    filter: (file) => {
+      if (shouldSkip(file, skipPaths)) return false;
+      // Skip broken symlinks
+      try {
+        const st = fs.lstatSync(file);
+        if (st.isSymbolicLink()) {
+          try { fs.statSync(file); } catch { return false; }
+        }
+      } catch { return false; }
+      // Protect project-memory.md
+      if (file.endsWith('project-memory.md')) {
+        const rel = path.relative(srcAgents, file);
+        if (fs.pathExistsSync(path.join(destAgents, rel))) return false;
+      }
+      return true;
+    }
+  });
+}
+
+
+export async function install(rootDir, options = {}) {
+  if (options.global) {
+    return installGlobal(rootDir);
+  }
+  console.log('\n🌙 Luna AI Installer\n');
+
+  try {
+    const targetDir = process.cwd();
+    const claudeDir = path.join(targetDir, '.claude');
+    const agentsDir = path.join(targetDir, '.agents');
+    const opencodeDir = path.join(targetDir, '.opencode');
+
+    let isUpdate = false;
+    let isLunaProject = false;
+    let readVersionFile = null;
+
+    if (await fs.pathExists(path.join(claudeDir, 'version.json'))) {
+      readVersionFile = path.join(claudeDir, 'version.json');
+    } else if (await fs.pathExists(path.join(agentsDir, 'version.json'))) {
+      readVersionFile = path.join(agentsDir, 'version.json');
+    } else if (await fs.pathExists(path.join(opencodeDir, 'version.json'))) {
+      readVersionFile = path.join(opencodeDir, 'version.json');
+    }
+
+    if (await fs.pathExists(claudeDir) || await fs.pathExists(agentsDir) || await fs.pathExists(opencodeDir)) {
+      isUpdate = true;
+      if (readVersionFile) {
+        const versionInfo = await fs.readJson(readVersionFile);
+        if (versionInfo.framework === 'luna-ai') {
+          isLunaProject = true;
+        }
+      }
+    }
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: isUpdate ? 'Existing structure detected. What do you want to do?' : 'Confirm Luna AI framework installation?',
+        choices: isUpdate ? [
+          { name: isLunaProject ? 'Upgrade version (Keep knowledge)' : 'Convert to new framework (Backup old version)', value: 'upgrade' },
+          { name: 'Fresh install (Delete/Backup old)', value: 'fresh' },
+          { name: 'Exit', value: 'exit' }
+        ] : [
+          { name: 'Install (Standard)', value: 'install' },
+          { name: 'Exit', value: 'exit' }
+        ]
+      }
+    ]);
+
+    if (answers.action === 'exit') return;
+
+    let previousAgents = [];
+    if (readVersionFile) {
+      const vInfo = await fs.readJson(readVersionFile);
+      previousAgents = vInfo.agents || ['claude'];
+    }
+    const selectedAgents = await agentSelectionPrompt(isUpdate, previousAgents);
+
+    console.log(`\n  Installing agents: ${selectedAgents.join(', ')}`);
+    console.log(`\n Processing system...`);
+
+    if (isUpdate) {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupDir = `${claudeDir}_backup_${timestamp}`;
+
+      if (answers.action === 'fresh' || !isLunaProject) {
+        console.log(` Backing up old structure at: ${backupDir}`);
+        await fs.copy(claudeDir, backupDir);
+        // Backup .agents/ if exists
+        const agentsDir = path.join(targetDir, '.agents');
+        if (await fs.pathExists(agentsDir)) {
+          const agentsBackupDir = path.join(targetDir, `.agents_backup_${timestamp}`);
+          await fs.copy(agentsDir, agentsBackupDir);
+          console.log(` Backing up .agents/ at: ${agentsBackupDir}`);
+        }
+        if (answers.action === 'fresh') await fs.remove(claudeDir);
+      }
+
+      if (isLunaProject && answers.action === 'upgrade') {
+        console.log(' Upgrading core components (Skills, Agents, Workflow)...');
+        // Delete then copy new (clean replace) to remove old renamed skills/agents/workflow/rules
+        const coreFolders = ['skills', 'agents', 'workflow', 'rules'];
+        for (const folder of coreFolders) {
+          const folderPath = path.join(claudeDir, folder);
+          let st = null;
+          try { st = await lstat(folderPath); } catch { /* skip */ }
+          // Only delete if it's a real directory (not a symlink)
+          if (st && !st.isSymbolicLink()) await fs.remove(folderPath);
+        }
+        // Copy new with filter (exclude dev-only skills & local config & rules symlink)
+        if (selectedAgents.includes('claude')) {
+          await copyClaude(rootDir, targetDir);
+        }
+        if (selectedAgents.includes('opencode')) {
+          await copyOpencode(rootDir, targetDir);
+        }
+        
+        // Delete old commands (converted to skills since v2.7.0)
+        const oldCommandsDir = path.join(claudeDir, 'commands');
+        if (await fs.pathExists(oldCommandsDir)) {
+          await fs.remove(oldCommandsDir);
+          console.log(' Deleted .claude/commands/ (converted to skills)');
+        }
+        
+        if (selectedAgents.includes('claude')) {
+          await fs.copy(getCanonicalClaudeMd(rootDir), path.join(targetDir, 'CLAUDE.md'));
+          await ensureGeminiSymlink(targetDir);
+        }
+        
+        // Clean replace .agents/ (skills for editor/IDE discovery)
+        if (selectedAgents.includes('antigravity')) {
+          const destAgents = path.join(targetDir, '.agents');
+          await fs.remove(destAgents);
+          await copyAgentsLocal(rootDir, targetDir);
+        }
+        
+        if (selectedAgents.includes('claude')) {
+          // Ensure .claude/rules is symlink → .agents/rules
+          await ensureRulesSymlink(targetDir);
+        }
+        console.log(' Preserved: ai-cache/, plans/ (not overwritten)');
+      } else {
+        if (selectedAgents.includes('claude')) {
+          await copyClaude(rootDir, targetDir);
+          await fs.copy(getCanonicalClaudeMd(rootDir), path.join(targetDir, 'CLAUDE.md'));
+          await ensureGeminiSymlink(targetDir);
+          await ensureRulesSymlink(targetDir);
+        }
+        if (selectedAgents.includes('opencode')) {
+          await copyOpencode(rootDir, targetDir);
+        }
+        if (selectedAgents.includes('antigravity')) {
+          await copyAgentsLocal(rootDir, targetDir);
+        }
+      }
+    } else {
+      if (selectedAgents.includes('claude')) {
+        await copyClaude(rootDir, targetDir);
+        await fs.copy(getCanonicalClaudeMd(rootDir), path.join(targetDir, 'CLAUDE.md'));
+        await ensureGeminiSymlink(targetDir);
+        await ensureRulesSymlink(targetDir);
+      }
+      if (selectedAgents.includes('opencode')) {
+        await copyOpencode(rootDir, targetDir);
+      }
+      if (selectedAgents.includes('antigravity')) {
+        await copyAgentsLocal(rootDir, targetDir);
+      }
+    }
+
+    const pkgJson = await fs.readJson(path.join(rootDir, 'package.json'));
+    const versionConfig = {
+      framework: 'luna-ai',
+      version: pkgJson.version,
+      installedAt: new Date().toISOString().split('T')[0],
+      agents: selectedAgents
+    };
+
+    if (selectedAgents.includes('claude')) {
+      await fs.ensureDir(claudeDir);
+      await fs.writeJson(path.join(claudeDir, 'version.json'), versionConfig, { spaces: 2 });
+    }
+    if (selectedAgents.includes('opencode')) {
+      await fs.ensureDir(opencodeDir);
+      await fs.writeJson(path.join(opencodeDir, 'version.json'), versionConfig, { spaces: 2 });
+    }
+    if (selectedAgents.includes('antigravity')) {
+      await fs.ensureDir(agentsDir);
+      await fs.writeJson(path.join(agentsDir, 'version.json'), versionConfig, { spaces: 2 });
+    }
+
+    await fs.ensureDir(path.join(targetDir, 'plans/archive'));
+
+    console.log('\n✅ Installation complete!');
+    console.log('\n📋 NEXT STEPS:');
+    if (selectedAgents.includes('claude')) {
+      console.log('  Claude: Run "luna init" then open Claude Code');
+    }
+    if (selectedAgents.includes('opencode')) {
+      console.log('  OpenCode: Run "opencode" in your project');
+    }
+    if (selectedAgents.includes('antigravity')) {
+      console.log('  Antigravity: Open Antigravity IDE');
+    }
+    console.log('');
+
+  } catch (error) {
+    console.error('\n An error occurred:', error);
+  }
+}
+
+/**
+ * Copy canonical .claude/ to global target directory (~/.claude/), skip settings.json to protect
+ * user's original Claude Code configuration.
+ */
+async function copyClaude_global(rootDir, claudeHome) {
+  const srcClaude = getCanonicalClaudeDir(rootDir);
+  if (!await fs.pathExists(srcClaude)) {
+    throw new Error(`Canonical Claude directory missing: ${srcClaude}`);
+  }
+  const destClaude = claudeHome;
+  const skipPaths = [
+    path.join(srcClaude, 'ai-cache'),
+    path.join(srcClaude, 'hook-state'),          // Runtime data, don't copy
+    path.join(srcClaude, 'settings.local.json'),
+    path.join(srcClaude, 'settings.json'),       // Protect original Claude Code settings
+    path.join(srcClaude, 'rules'),               // Created via ensureAgentsFolderSymlink
+    path.join(srcClaude, 'skills'),              // Created via ensureAgentsFolderSymlink
+    path.join(srcClaude, 'agents'),              // Created via ensureAgentsFolderSymlink
+    path.join(srcClaude, 'workflows'),           // Created via ensureAgentsFolderSymlink
+    path.join(srcClaude, 'hooks'),               // Created via ensureAgentsFolderSymlink
+    ...DEV_ONLY_SKILLS.map(s => path.join(srcClaude, 'skills', s)),
+  ];
+  await fs.copy(srcClaude, destClaude, {
+    dereference: true,
+    filter: (file) => {
+      if (shouldSkip(file, skipPaths)) return false;
+      if (file.endsWith('project-memory.md')) {
+        const relativePath = path.relative(srcClaude, file);
+        const destPath = path.join(destClaude, relativePath);
+        if (fs.pathExistsSync(destPath)) return false;
+      }
+      return true;
+    }
+  });
+}
+
+
+
+/**
+ * Install Luna AI framework in GLOBAL mode.
+ *
+ * Strategy:
+ *   ~/.claude/        ← Skills, agents, workflows, rules, hooks (Claude Code reads here)
+ *   ~/.luna-ai/       ← Metadata: plans/, ai-cache/, CLAUDE.md, GEMINI.md
+ *
+ * Use when running 'luna --global' or 'luna install --global'
+ */
+export async function installGlobal(rootDir) {
+  const homeDir    = os.homedir();
+  const lunaHome   = path.join(homeDir, '.luna-ai');    // metadata
+  const claudeHome = getClaudeConfigDir();     // Claude Code global dir
+  const agentsHome = path.join(homeDir, '.agents');     // agents/skills/workflows
+  const opencodeHome = path.join(homeDir, '.opencode');
+
+  console.log(`\n🌙 Luna AI – GLOBAL Install`);
+  console.log(`   ${claudeHome}  ← Skills, Agents, Hooks, Rules (Claude Code reads here)`);
+  console.log(`   ~/.luna-ai/ ← Metadata (plans, ai-cache)\n`);
+
+  try {
+    let isUpdate = false;
+    let isLunaProject = false;
+    let readVersionFile = null;
+
+    if (await fs.pathExists(path.join(claudeHome, 'version.json'))) {
+      readVersionFile = path.join(claudeHome, 'version.json');
+    } else if (await fs.pathExists(path.join(agentsHome, 'version.json'))) {
+      readVersionFile = path.join(agentsHome, 'version.json');
+    } else if (await fs.pathExists(path.join(opencodeHome, 'version.json'))) {
+      readVersionFile = path.join(opencodeHome, 'version.json');
+    }
+
+    if (await fs.pathExists(claudeHome) || await fs.pathExists(agentsHome) || await fs.pathExists(opencodeHome)) {
+      isUpdate = true;
+      if (readVersionFile) {
+        const versionInfo = await fs.readJson(readVersionFile);
+        if (versionInfo.framework === 'luna-ai') {
+          isLunaProject = true;
+        }
+      }
+    }
+
+    // Also check old install at ~/.luna-ai/.claude/ to support migration
+    const legacyClaudeDir = path.join(lunaHome, '.claude');
+    const hasLegacy = await fs.pathExists(legacyClaudeDir);
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: isUpdate
+          ? `Existing global framework detected at ~/.claude/. What do you want to do?`
+          : hasLegacy
+            ? `Old install detected at ~/.luna-ai/ (old version). What do you want to do?`
+            : `Confirm global Luna AI framework installation?`,
+        choices: isUpdate ? [
+          { name: isLunaProject ? 'Upgrade version (Keep knowledge)' : 'Convert to new framework (Backup old version)', value: 'upgrade' },
+          { name: 'Merge (Merge new framework into old — keep user-added files)', value: 'merge' },
+          { name: 'Fresh install (Delete/Backup old)', value: 'fresh' },
+          { name: 'Exit', value: 'exit' }
+        ] : [
+          { name: hasLegacy ? 'Migrate from ~/.luna-ai/ to ~/.claude/ (recommended)' : 'Install globally into ~/.claude/', value: 'install' },
+          { name: 'Exit', value: 'exit' }
+        ]
+      }
+    ]);
+
+    if (answers.action === 'exit') return;
+
+    let previousAgents = [];
+    if (readVersionFile) {
+      const vInfo = await fs.readJson(readVersionFile);
+      previousAgents = vInfo.agents || ['claude'];
+    }
+    const selectedAgents = await agentSelectionPrompt(isUpdate, previousAgents);
+
+    console.log(`\n  Installing agents: ${selectedAgents.join(', ')}`);
+    console.log(`\n Processing global installation...`);
+
+    // Create directories
+    await fs.ensureDir(lunaHome);
+    await fs.ensureDir(claudeHome);
+
+    if (isUpdate) {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+
+      if (answers.action === 'fresh' || !isLunaProject) {
+        const backupDir = `${claudeHome}_luna_backup_${timestamp}`;
+        console.log(` Backing up old structure at: ${backupDir}`);
+        await fs.copy(claudeHome, backupDir);
+        if (await fs.pathExists(agentsHome)) {
+          const agentsBackupDir = path.join(homeDir, `.agents_backup_${timestamp}`);
+          await fs.copy(agentsHome, agentsBackupDir);
+          console.log(` Backing up ~/.agents/ at: ${agentsBackupDir}`);
+        }
+        if (answers.action === 'fresh') {
+          // Only delete Luna folders, not entire ~/.claude/
+          const lunaFolders = ['skills', 'agents', 'workflows', 'workflow', 'rules'];
+          for (const folder of lunaFolders) {
+            await fs.remove(path.join(claudeHome, folder));
+          }
+          await fs.remove(path.join(claudeHome, 'version.json'));
+          await fs.remove(agentsHome);
+        }
+      }
+
+      if (answers.action === 'merge') {
+        // Merge: update framework files (overwrite: true) but DON'T delete coreFolders first
+        // → User-added files preserved; old skills/agents/workflows updated
+        console.log(' Merge: Updating framework, keeping user-added files...');
+        const mergeBackupDir = `${claudeHome}_luna_backup_${timestamp}`;
+        console.log(` Pre-merge backup: ${mergeBackupDir}`);
+        await fs.copy(claudeHome, mergeBackupDir);
+        if (await fs.pathExists(agentsHome)) {
+          const agentsMergeBackup = path.join(homeDir, `.agents_backup_${timestamp}`);
+          await fs.copy(agentsHome, agentsMergeBackup);
+          console.log(` Pre-merge ~/.agents/ backup: ${agentsMergeBackup}`);
+        }
+        // copy with overwrite:true — overwrite framework files, keep non-framework files
+        if (selectedAgents.includes('claude')) {
+          await copyClaude_global(rootDir, claudeHome);
+          await copyAgentsFoldersToClaude(rootDir, claudeHome);
+          await copyAgentsSupportFiles(rootDir, claudeHome);
+        }
+        if (selectedAgents.includes('opencode')) {
+          await copyOpencode(rootDir, homeDir);
+        }
+        if (selectedAgents.includes('antigravity')) {
+          await copyAgentsLocal(rootDir, homeDir);
+        }
+        console.log(' Merge complete — user-added files preserved.');
+      } else if (isLunaProject && answers.action === 'upgrade') {
+        console.log(' Upgrading core components (Skills, Agents, Workflow)...');
+        // Backup before delete (in case of mid-process errors)
+        const upgradeBackupDir = `${claudeHome}_luna_backup_${timestamp}`;
+        console.log(` Backing up ~/.claude/ before upgrade: ${upgradeBackupDir}`);
+        await fs.copy(claudeHome, upgradeBackupDir);
+        if (await fs.pathExists(agentsHome)) {
+          const agentsUpgradeBackup = path.join(homeDir, `.agents_backup_${timestamp}`);
+          await fs.copy(agentsHome, agentsUpgradeBackup);
+          console.log(` Backing up ~/.agents/ before upgrade: ${agentsUpgradeBackup}`);
+        }
+        // Delete old directories (not symlinks) for clean replace
+        const coreFolders = ['skills', 'agents', 'workflow', 'workflows', 'rules'];
+        for (const folder of coreFolders) {
+          const folderPath = path.join(claudeHome, folder);
+          let st = null;
+          try { st = await lstat(folderPath); } catch { /* skip */ }
+          if (st && !st.isSymbolicLink()) await fs.remove(folderPath);
+        }
+        if (selectedAgents.includes('claude')) {
+          await copyClaude_global(rootDir, claudeHome);
+          await copyAgentsFoldersToClaude(rootDir, claudeHome);
+          await copyAgentsSupportFiles(rootDir, claudeHome);
+        }
+        if (selectedAgents.includes('opencode')) {
+          await copyOpencode(rootDir, homeDir);
+        }
+        if (selectedAgents.includes('antigravity')) {
+          const destAgents = path.join(homeDir, '.agents');
+          await fs.remove(destAgents);
+          await copyAgentsLocal(rootDir, homeDir);
+        }
+        console.log(' Preserved: ai-cache/, plans/, settings.json (not overwritten)');
+      } else {
+        if (selectedAgents.includes('claude')) {
+          await copyClaude_global(rootDir, claudeHome);
+          await copyAgentsFoldersToClaude(rootDir, claudeHome);
+          await copyAgentsSupportFiles(rootDir, claudeHome);
+        }
+        if (selectedAgents.includes('opencode')) {
+          await copyOpencode(rootDir, homeDir);
+        }
+        if (selectedAgents.includes('antigravity')) {
+          await copyAgentsLocal(rootDir, homeDir);
+        }
+      }
+    } else {
+      // First-time install, or migrate from ~/.luna-ai/
+      // Backup if ~/.claude/ or ~/.agents/ already exists (even if not Luna)
+      const freshTimestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const claudeExists = await fs.pathExists(claudeHome);
+      const agentsExists = await fs.pathExists(agentsHome);
+      if (claudeExists) {
+        const freshBackupDir = `${claudeHome}_luna_backup_${freshTimestamp}`;
+        console.log(` Backing up existing ~/.claude/ before install: ${freshBackupDir}`);
+        await fs.copy(claudeHome, freshBackupDir);
+      }
+      if (agentsExists) {
+        const agentsFreshBackup = path.join(homeDir, `.agents_backup_${freshTimestamp}`);
+        console.log(` Backing up existing ~/.agents/ before install: ${agentsFreshBackup}`);
+        await fs.copy(agentsHome, agentsFreshBackup);
+      }
+      if (hasLegacy) {
+        console.log(' Old install detected at ~/.luna-ai/ — migrating...');
+        // plans/ and ai-cache/ already at ~/.luna-ai/ (correct location) — no need to copy
+        console.log(' Migration complete — old data preserved at ~/.luna-ai/');
+      }
+      // Remove existing ~/.agents/ (already backed up above) to avoid conflicts
+      if (agentsExists) {
+        await fs.remove(agentsHome);
+      }
+      if (selectedAgents.includes('claude')) {
+        await copyClaude_global(rootDir, claudeHome);
+        await copyAgentsFoldersToClaude(rootDir, claudeHome);
+        await copyAgentsSupportFiles(rootDir, claudeHome);
+      }
+      if (selectedAgents.includes('opencode')) {
+        await copyOpencode(rootDir, homeDir);
+      }
+      if (selectedAgents.includes('antigravity')) {
+        await copyAgentsLocal(rootDir, homeDir);
+      }
+    }
+
+    if (selectedAgents.includes('claude')) {
+      // Write settings.json with absolute paths for global hooks (replace $CLAUDE_PROJECT_DIR → absolute)
+      await writeGlobalSettingsJson(rootDir, claudeHome);
+
+      // Copy statusline.cjs and its lib/ dependency from .agents/ to ~/.claude/
+      const statuslineSrc = path.join(rootDir, '.agents', 'statusline.cjs');
+      if (await fs.pathExists(statuslineSrc)) {
+        await fs.copy(statuslineSrc, path.join(claudeHome, 'statusline.cjs'), { overwrite: true });
+        // statusline.cjs requires ./lib/ — copy lib/ to ~/.claude/lib/
+        const libSrc = path.join(rootDir, '.agents', 'lib');
+        if (await fs.pathExists(libSrc)) {
+          await fs.copy(libSrc, path.join(claudeHome, 'lib'), { overwrite: true });
+        }
+        console.log(` Copied statusline.cjs + lib/ → ~/.claude/`);
+      }
+
+      // Copy canonical .luna.json to ~/.claude/.luna.json
+      const lunaJsonSrc = path.join(rootDir, 'agentic', 'claude', '.luna.json');
+
+      if (await fs.pathExists(lunaJsonSrc)) {
+        await fs.copy(lunaJsonSrc, path.join(claudeHome, '.luna.json'), { overwrite: true });
+        console.log(` Copied .luna.json → ~/.claude/.luna.json`);
+      } else {
+        console.log(' Warning: canonical agentic/claude/.luna.json missing. Skip publishing ~/.claude/.luna.json');
+      }
+
+      // Ensure luna CLI is available at ~/.local/bin/luna
+      await ensureLunaCli(claudeHome);
+
+      // Copy CLAUDE.md into ~/.claude/ (Claude Code reads global instructions from here)
+      await fs.copy(getCanonicalClaudeMd(rootDir), path.join(claudeHome, 'CLAUDE.md'), { overwrite: true });
+      await ensureGeminiSymlink(claudeHome);
+    }
+
+    // Copy CLAUDE.md + GEMINI.md symlink into ~/.luna-ai/ (as reference)
+    await fs.copy(getCanonicalClaudeMd(rootDir), path.join(lunaHome, 'CLAUDE.md'), { overwrite: true });
+    await ensureGeminiSymlink(lunaHome);
+
+    // Create plans/archive directory at ~/.luna-ai/
+    await fs.ensureDir(path.join(lunaHome, 'plans', 'archive'));
+
+    const pkgJson = await fs.readJson(path.join(rootDir, 'package.json'));
+    const versionConfig = {
+      framework: 'luna-ai',
+      version: pkgJson.version,
+      installedAt: new Date().toISOString().split('T')[0],
+      agents: selectedAgents
+    };
+
+    if (selectedAgents.includes('claude')) {
+      await fs.ensureDir(claudeHome);
+      await fs.writeJson(path.join(claudeHome, 'version.json'), versionConfig, { spaces: 2 });
+      await fs.writeFile(path.join(claudeHome, '.luna-framework-root'), rootDir);
+      console.log(` Stored framework root → ~/.claude/.luna-framework-root`);
+    }
+    if (selectedAgents.includes('opencode')) {
+      await fs.ensureDir(opencodeHome);
+      await fs.writeJson(path.join(opencodeHome, 'version.json'), versionConfig, { spaces: 2 });
+    }
+    if (selectedAgents.includes('antigravity')) {
+      await fs.ensureDir(agentsHome);
+      await fs.writeJson(path.join(agentsHome, 'version.json'), versionConfig, { spaces: 2 });
+    }
+    console.log(` Created version.json (v${pkgJson.version}) in selected agent directories`);
+
+    // Init ai-cache/ at ~/.luna-ai/ai-cache/
+    const aiCacheDir = path.join(lunaHome, 'ai-cache');
+    const cacheMeta  = path.join(aiCacheDir, 'cache-meta.json');
+    if (!await fs.pathExists(cacheMeta)) {
+      await fs.ensureDir(path.join(aiCacheDir, 'modules'));
+      await fs.writeFile(path.join(aiCacheDir, 'modules', '.gitkeep'), '');
+      await initGlobalCacheFiles(aiCacheDir);
+      console.log(` ai-cache/ initialized at: ${aiCacheDir}`);
+    } else {
+      console.log(` ai-cache/ already exists — keeping as is.`);
+    }
+
+    console.log(`\n✅ Global installation complete!`);
+    console.log(`\n📌 Structure:`);
+    if (selectedAgents.includes('claude')) {
+      console.log(`   ~/.claude/    ← Skills, Agents, Hooks, Rules`);
+    }
+    if (selectedAgents.includes('opencode')) {
+      console.log(`   ~/.opencode/  ← OpenCode Agent Config`);
+    }
+    if (selectedAgents.includes('antigravity')) {
+      console.log(`   ~/.agents/    ← Antigravity Base Setup`);
+    }
+    console.log(`   ~/.luna-ai/   ← Metadata (plans, ai-cache, CLAUDE.md)`);
+    console.log(`\n📋 NEXT STEPS:`);
+    if (selectedAgents.includes('claude')) {
+      console.log(`   Claude: run 'luna init -g' then read ~/.claude/CLAUDE.md`);
+    }
+    if (selectedAgents.includes('opencode')) {
+      console.log(`   OpenCode: run 'opencode' globally`);
+    }
+    if (selectedAgents.includes('antigravity')) {
+      console.log(`   Antigravity: open Antigravity IDE globally`);
+    }
+    console.log('');
+
+  } catch (error) {
+    console.error('\n An error occurred during global install:', error);
+  }
+}
+
+/**
+ * Ensure luna CLI symlink exists at ~/.local/bin/luna.
+ * Points to the installed copy at ~/.claude/skills/luna-cli/bin/luna.
+ */
+async function ensureLunaCli(claudeHome) {
+  const lunaBin = path.join(claudeHome, 'skills', 'luna-cli', 'bin', 'luna');
+  if (!await fs.pathExists(lunaBin)) return;
+
+  const localBinDir = path.join(os.homedir(), '.local', 'bin');
+  await fs.ensureDir(localBinDir);
+  const destBin = path.join(localBinDir, 'luna');
+
+  let st = null;
+  try { st = await lstat(destBin); } catch { /* doesn't exist */ }
+
+  if (st) {
+    if (st.isSymbolicLink()) {
+      await unlink(destBin); // Remove old symlink, recreate with correct target
+    } else {
+      return; // Real file (user-managed), don't touch
+    }
+  }
+
+  await symlink(lunaBin, destBin);
+  console.log(` Symlinked luna CLI → ~/.local/bin/luna`);
+}
+
+/**
+ * Write settings.json into ~/.claude/ for global install.
+ * Reads from .agents/settings.json (source of truth) and overwrites ~/.claude/settings.json.
+ */
+async function writeGlobalSettingsJson(rootDir, claudeHome) {
+  const srcPath  = path.join(rootDir, '.agents', 'settings.json');
+  const destPath = path.join(claudeHome, 'settings.json');
+
+  if (!await fs.pathExists(srcPath)) return;
+
+  await fs.copy(srcPath, destPath, { overwrite: true });
+  console.log(` Copied .agents/settings.json → ~/.claude/settings.json`);
+}
+
+/**
+ * Initialize initial cache files for global environment.
+ * (Similar to initCacheFiles in init.js but doesn't need addToGitignore)
+ */
+async function initGlobalCacheFiles(cacheDir) {
+  const cacheMeta = {
+    version: '2.0',
+    project_scale: 'auto',
+    scale_thresholds: {
+      small:  { max_files: 50,  max_modules: 5  },
+      medium: { max_files: 200, max_modules: 20 },
+      large:  { min_files: 200, min_modules: 20 }
+    },
+    layers: {
+      L1: { file: 'context-snapshot.md', sources: ['STRUCTURE.md', 'KNOWLEDGE_GRAPH.md', 'project-memory.md'] },
+      L2: { directory: 'modules/',        description: 'Module-specific cache (large projects)' },
+      L3: { file: 'hot-files.md',         description: 'Frequently changed files' }
+    },
+    cache_valid: false,
+    last_rebuild: null,
+    hashes: {}
+  };
+  await fs.writeJson(path.join(cacheDir, 'cache-meta.json'), cacheMeta, { spaces: 2 });
+
+  await fs.writeFile(path.join(cacheDir, 'context-snapshot.md'),
+    `# Context Snapshot (L1 Cache – Global)\n\n*Cache not initialized. Run "luna --global init" to build cache.*\n\n## Project Overview\n- **Status**: Pending initialization\n`
+  );
+
+  await fs.writeFile(path.join(cacheDir, 'hot-files.md'),
+    `# Hot Files Cache (L3 – Global)\n\n*Will be auto-updated by Agent.*\n\n## Files\n`
+  );
+}