@adityaaria/agent-os 1.0.0

package/scripts/install.mjs

@@ -0,0 +1,690 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { wantsHelp, showHelp } from './lib/cli-utils.mjs';
+
+if (wantsHelp(process.argv)) {
+  showHelp({
+    command: 'install',
+    description: 'Install Agent OS framework into a workspace',
+    usage: [
+      'agent-os install --workspace-file <file> --all [options]',
+      'agent-os install --target <dir> --allow-target-install [options]'
+    ],
+    required: [
+      { flag: '--workspace-file <file>', desc: 'Path to .code-workspace file' }
+    ],
+    options: [
+      { flag: '--all', desc: 'Install all IDE adapters (cursor, claude, codex, antigravity)' },
+      { flag: '--backup', desc: 'Backup existing files before overwriting' },
+      { flag: '--force', desc: 'Force overwrite on conflicts' },
+      { flag: '--dry-run', desc: 'Preview changes without writing files' },
+      { flag: '--verbose', desc: 'Show detailed output' },
+      { flag: '--target <dir>', desc: 'Install to explicit target (dev/test only)' },
+      { flag: '--allow-target-install', desc: 'Required with --target' }
+    ],
+    examples: [
+      'agent-os install --workspace-file ./my-project.code-workspace --all --backup',
+      'agent-os install --workspace-file ./my-project.code-workspace --all --dry-run'
+    ]
+  });
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, '..');
+
+const args = process.argv.slice(2);
+function hasFlag(name) { return args.includes(name); }
+function getArg(name, fallback = null) {
+  const idx = args.indexOf(name);
+  if (idx === -1) return fallback;
+  return args[idx + 1] ?? fallback;
+}
+
+const isDryRun = hasFlag('--dry-run');
+const isVerbose = hasFlag('--verbose');
+const doBackup = hasFlag('--backup') || hasFlag('--force');
+const force = hasFlag('--force');
+
+const workspaceFileInput = getArg('--workspace-file', null);
+const hasTargetFlag = hasFlag('--target');
+const allowTargetInstall = hasFlag('--allow-target-install');
+
+if (workspaceFileInput && hasTargetFlag) {
+  console.error("CRITICAL: Cannot use --target and --workspace-file together.");
+  process.exit(1);
+}
+
+if (!workspaceFileInput && !allowTargetInstall) {
+  console.error("CRITICAL: --workspace-file is required for installation. Use --allow-target-install only for explicit development/test installs.");
+  console.error("  Run 'agent-os install --help' for full usage.");
+  process.exit(1);
+}
+
+let target;
+let workspaceMode = false;
+let workspaceData = null;
+let workspaceName = '';
+
+if (workspaceFileInput) {
+  const absWorkspaceFile = path.resolve(process.cwd(), workspaceFileInput);
+  if (!fs.existsSync(absWorkspaceFile)) {
+    console.error(`CRITICAL: Workspace file not found: ${absWorkspaceFile}`);
+    process.exit(1);
+  }
+  const rawContent = fs.readFileSync(absWorkspaceFile, 'utf8');
+  const cleanContent = rawContent.replace(/\/\/.*|\/\*[\s\S]*?\*\//g, '');
+  let wsJson;
+  try {
+    wsJson = JSON.parse(cleanContent);
+  } catch (err) {
+    console.error(`CRITICAL: Failed to parse workspace JSON: ${err.message}`);
+    process.exit(1);
+  }
+  if (!wsJson.folders || !Array.isArray(wsJson.folders)) {
+    console.error(`CRITICAL: Workspace file missing 'folders' array.`);
+    process.exit(1);
+  }
+  
+  workspaceMode = true;
+  workspaceName = path.basename(absWorkspaceFile, '.code-workspace');
+  const workspaceDir = path.dirname(absWorkspaceFile);
+  target = path.join(workspaceDir, '.agent-os-workspace');
+  
+  const resolvedFolders = [];
+  for (const f of wsJson.folders) {
+    if (f.path) {
+      const absPath = path.resolve(workspaceDir, f.path);
+      if (fs.existsSync(absPath)) {
+        resolvedFolders.push({ name: f.name || path.basename(absPath), path: absPath });
+      } else {
+        console.warn(`[WARN] Workspace folder not found: ${absPath}`);
+      }
+    }
+  }
+  
+  workspaceData = {
+    file: absWorkspaceFile,
+    name: workspaceName,
+    folders: resolvedFolders,
+    json: wsJson
+  };
+} else {
+  const targetInput = getArg('--target', '.');
+  target = path.resolve(process.cwd(), targetInput);
+}
+
+const stats = { copied: 0, skipped: 0, overwritten: 0, backedUp: 0, errors: 0, conflicts: 0, workspaceFileUpdated: false, workspaceFileBackupPath: null, agentOsWorkspaceEntry: null };
+const rollbackLog = []; 
+let logStream = null;
+
+if (!isDryRun) {
+  try {
+    if (!fs.existsSync(target)) fs.mkdirSync(target, { recursive: true });
+    logStream = fs.createWriteStream(path.join(target, 'install.log'), { flags: 'a' });
+  } catch (err) {
+    console.error(`CRITICAL: Cannot write to target directory. ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function log(msg, verboseOnly = false) {
+  if (verboseOnly && !isVerbose) return;
+  const logMsg = `[${new Date().toISOString()}] ${msg}`;
+  console.log(msg);
+  if (logStream) logStream.write(logMsg + '\n');
+}
+
+function logError(msg) {
+  log(`[ERROR] ${msg}`);
+  stats.errors++;
+  if (!force) {
+    log(`[ABORT] Fatal error encountered and --force not provided. Rolling back...`);
+    rollback();
+    process.exit(1);
+  }
+}
+
+function rollback() {
+  log('--- ROLLBACK INITIATED ---');
+  if (isDryRun) {
+    log('Dry run: rollback is a no-op.');
+    return;
+  }
+  const rollbackActions = [...rollbackLog];
+  rollbackActions.reverse();
+  for (const action of rollbackActions) {
+    try {
+      rollbackAction(action);
+    } catch (err) {
+      log(`Rollback Failed for ${action.dest}: ${err.message}`);
+    }
+  }
+  log('--- ROLLBACK COMPLETE ---');
+}
+
+function rollbackAction(action) {
+  if (action.type === 'copy') {
+    rollbackCopy(action);
+    return;
+  }
+  if (action.type === 'mkdir') rollbackDirectory(action.dest);
+}
+
+function rollbackCopy(action) {
+  if (fs.existsSync(action.dest)) {
+    fs.unlinkSync(action.dest);
+    log(`Rollback: Deleted ${action.dest}`, true);
+  }
+  if (action.backup) {
+    fs.renameSync(action.backup, action.dest);
+    log(`Rollback: Restored ${action.dest} from backup`, true);
+  }
+}
+
+function rollbackDirectory(dir) {
+  if (fs.existsSync(dir) && fs.readdirSync(dir).length === 0) {
+    fs.rmdirSync(dir);
+    log(`Rollback: Removed empty directory ${dir}`, true);
+  }
+}
+
+log('=== Agent OS v1.0.0 Production Installer ===');
+if (isDryRun) log('MODE: DRY RUN');
+if (workspaceMode) log(`MODE: WORKSPACE (${workspaceName})`);
+
+function checkPermissions(dir) {
+  try {
+    fs.accessSync(dir, fs.constants.W_OK);
+    return true;
+  } catch (err) {
+    log(`Permission check failed for ${dir}: ${err.message}`, true);
+    return false;
+  }
+}
+
+if (!isDryRun && !checkPermissions(target)) {
+  logError(`Target workspace is not writable: ${target}`);
+}
+
+// Version Validation
+const CURRENT_VERSION = "1.0.0";
+const targetVersionFile = path.join(target, '.agent-os', 'VERSION');
+if (fs.existsSync(targetVersionFile)) {
+  const existingVersion = fs.readFileSync(targetVersionFile, 'utf8').trim();
+  log(`Detected existing installation: v${existingVersion}`);
+  if (existingVersion !== CURRENT_VERSION && existingVersion > CURRENT_VERSION) {
+    logError(`Downgrade detected! Target has v${existingVersion}, installer is v${CURRENT_VERSION}.`);
+  }
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    if (!isDryRun) fs.mkdirSync(dir, { recursive: true });
+    rollbackLog.push({ type: 'mkdir', dest: dir });
+    log(`Created directory: ${dir}`, true);
+  }
+}
+
+function backupFile(dest) {
+  if (fs.existsSync(dest) && doBackup) {
+    const backupPath = `${dest}.bak_${Date.now()}`;
+    if (!isDryRun) fs.copyFileSync(dest, backupPath);
+    log(`Backed up: ${dest} -> ${backupPath}`, true);
+    stats.backedUp++;
+    return backupPath;
+  }
+  return null;
+}
+
+function copyFile(src, dest) {
+  if (!fs.existsSync(src)) {
+    logError(`Source does not exist: ${src}`);
+    return;
+  }
+  ensureDir(path.dirname(dest));
+  
+  let backupPath = null;
+  let isOverwrite = false;
+  
+  if (fs.existsSync(dest)) {
+    // Conflict Detection
+    const srcStat = fs.statSync(src);
+    const destStat = fs.statSync(dest);
+    if (destStat.size !== srcStat.size) {
+      log(`[CONFLICT] Size mismatch for ${dest}. Source: ${srcStat.size}b, Target: ${destStat.size}b`);
+      stats.conflicts++;
+      if (!force && !doBackup) {
+        logError(`Conflict detected in ${dest}. Use --force to overwrite or --backup to save existing.`);
+        return;
+      }
+    }
+    backupPath = backupFile(dest);
+    isOverwrite = true;
+  }
+  
+  try {
+    if (!isDryRun) fs.copyFileSync(src, dest);
+    rollbackLog.push({ type: 'copy', dest, backup: backupPath });
+    
+    if (isOverwrite) {
+      log(`Overwritten: ${dest}`, true);
+      stats.overwritten++;
+    } else {
+      log(`Copied: ${src} -> ${dest}`, true);
+      stats.copied++;
+    }
+  } catch (err) {
+    logError(`Failed to copy ${src} to ${dest}: ${err.message}`);
+  }
+}
+
+function copyRecursive(src, dest) {
+  if (!fs.existsSync(src)) {
+    logError(`Source does not exist: ${src}`);
+    return;
+  }
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    ensureDir(dest);
+    for (const item of fs.readdirSync(src)) {
+      copyRecursive(path.join(src, item), path.join(dest, item));
+    }
+  } else {
+    copyFile(src, dest);
+  }
+}
+
+function copyIfExists(src, dest) {
+  if (fs.existsSync(src)) {
+    copyRecursive(src, dest);
+  } else {
+    log(`Skipped (missing): ${src}`, true);
+    stats.skipped++;
+  }
+}
+
+function installAgentOS() {
+  const out = path.join(target, '.agent-os');
+  ensureDir(out);
+  if (!isDryRun) fs.writeFileSync(path.join(out, 'VERSION'), CURRENT_VERSION);
+  for (const item of ['AGENTS.md', 'ENTRYPOINT.md', 'AGENT_OS_BOOTSTRAP.md', 'plugin.json']) {
+    copyIfExists(path.join(repoRoot, item), path.join(out, item));
+  }
+  for (const dir of ['core', 'skills', 'templates', 'hooks', 'validators']) {
+    copyIfExists(path.join(repoRoot, dir), path.join(out, dir));
+  }
+  ensureDir(path.join(out, 'project'));
+  generateProjectKnowledgeBaseline(path.join(out, 'project'));
+  generateReportChannelsConfig(path.join(out, 'project'));
+}
+
+function writeIfMissing(filePath, content) {
+  if (fs.existsSync(filePath)) {
+    stats.skipped++;
+    log(`Skipped existing project knowledge: ${filePath}`, true);
+    return;
+  }
+
+  ensureDir(path.dirname(filePath));
+  if (!isDryRun) {
+    fs.writeFileSync(filePath, content);
+    rollbackLog.push({ type: 'copy', dest: filePath, backup: null });
+  }
+  stats.copied++;
+  log(`Generated project knowledge baseline: ${filePath}`, true);
+}
+
+function generateProjectKnowledgeBaseline(projectDir) {
+  for (const file of ['PROJECT_PROFILE.md', 'TECH_STACK.md', 'ARCHITECTURE.md']) {
+    const source = path.join(repoRoot, 'templates', file);
+    const content = fs.existsSync(source)
+      ? fs.readFileSync(source, 'utf8')
+      : `# ${path.basename(file, '.md')}\n\nN/A. Reason: Template source not available.\n`;
+    writeIfMissing(path.join(projectDir, file), content);
+  }
+
+  writeIfMissing(path.join(projectDir, 'WORKSPACE_MAP.md'), [
+    '# Agent OS Workspace Map',
+    '',
+    '- **Workspace Name**: direct-target-install',
+    '- **Workspace File**: N/A. Reason: Installed with explicit target mode.',
+    '- **Install Root**: N/A. Reason: Generated during installation.',
+    '',
+    '## Detected Folders',
+    '',
+    'N/A. Reason: No `.code-workspace` file was provided for this installation.',
+    ''
+  ].join('\n'));
+}
+
+function generateReportChannelsConfig(projectDir) {
+  const configPath = path.join(projectDir, 'report-channels.json');
+  if (fs.existsSync(configPath)) {
+    stats.skipped++;
+    log(`Skipped existing report channel config: ${configPath}`, true);
+    return;
+  }
+
+  const config = {
+    version: 1,
+    channels: {
+      spreadsheet: {
+        enabled: true,
+        type: 'file',
+        format: 'csv',
+        output: 'reports/runs.csv'
+      },
+      telegram: {
+        enabled: false,
+        type: 'telegram',
+        format: 'json',
+        output: 'reports/telegram-summary.json',
+        botTokenEnv: 'AGENT_OS_TELEGRAM_BOT_TOKEN',
+        chatIdEnv: 'AGENT_OS_TELEGRAM_CHAT_ID'
+      }
+    }
+  };
+
+  if (!isDryRun) {
+    fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+    rollbackLog.push({ type: 'copy', dest: configPath, backup: null });
+  }
+  stats.copied++;
+  log(`Generated report channel config: ${configPath}`, true);
+}
+
+function readIfExists(file) {
+  return fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+}
+
+function hasAnyFile(dir, names) {
+  return names.some((name) => fs.existsSync(path.join(dir, name)));
+}
+
+function projectTech(role, pm, framework, languages) {
+  return { role, pm, framework, languages };
+}
+
+function roleFromJavaScriptFramework(framework) {
+  if (['react', 'vue', 'nextjs'].includes(framework)) return 'frontend';
+  if (['nestjs', 'express'].includes(framework)) return 'backend';
+  return 'unknown';
+}
+
+function packageManagerForJavaScript(dir) {
+  if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (fs.existsSync(path.join(dir, 'yarn.lock'))) return 'yarn';
+  return 'npm';
+}
+
+function detectJavaScriptProject(dir) {
+  if (!fs.existsSync(path.join(dir, 'package.json'))) return null;
+
+  const languages = ['JavaScript'];
+  if (hasAnyFile(dir, ['tsconfig.json'])) languages.push('TypeScript');
+
+  const pkg = readIfExists(path.join(dir, 'package.json'));
+  let framework = 'unknown';
+  if (pkg.includes('"next"')) framework = 'nextjs';
+  else if (pkg.includes('"react"')) framework = 'react';
+  else if (pkg.includes('"vue"')) framework = 'vue';
+  else if (pkg.includes('"@nestjs/core"')) framework = 'nestjs';
+  else if (pkg.includes('"express"')) framework = 'express';
+
+  return projectTech(
+    roleFromJavaScriptFramework(framework),
+    packageManagerForJavaScript(dir),
+    framework,
+    languages
+  );
+}
+
+function detectPythonProject(dir) {
+  if (!hasAnyFile(dir, ['pyproject.toml', 'requirements.txt', 'Pipfile'])) return null;
+
+  const pythonConfig = [
+    readIfExists(path.join(dir, 'pyproject.toml')),
+    readIfExists(path.join(dir, 'requirements.txt')),
+    readIfExists(path.join(dir, 'Pipfile'))
+  ].join('\n').toLowerCase();
+
+  const pm = pythonConfig.includes('poetry') || fs.existsSync(path.join(dir, 'poetry.lock')) ? 'poetry' : 'pip';
+  let framework = 'unknown';
+  if (pythonConfig.includes('fastapi')) framework = 'fastapi';
+  else if (pythonConfig.includes('django')) framework = 'django';
+  else if (pythonConfig.includes('flask')) framework = 'flask';
+
+  return projectTech(framework === 'unknown' ? 'service' : 'backend', pm, framework, ['Python']);
+}
+
+function detectComposerProject(dir) {
+  if (!fs.existsSync(path.join(dir, 'composer.json'))) return null;
+
+  const composer = readIfExists(path.join(dir, 'composer.json')).toLowerCase();
+  let framework = 'unknown';
+  if (composer.includes('laravel/framework')) framework = 'laravel';
+  else if (composer.includes('symfony/')) framework = 'symfony';
+
+  return projectTech(framework === 'unknown' ? 'service' : 'backend', 'composer', framework, ['PHP']);
+}
+
+function detectRubyProject(dir) {
+  if (!hasAnyFile(dir, ['Gemfile', 'gems.rb'])) return null;
+
+  const gems = [
+    readIfExists(path.join(dir, 'Gemfile')),
+    readIfExists(path.join(dir, 'gems.rb'))
+  ].join('\n').toLowerCase();
+  const framework = gems.includes('rails') ? 'rails' : 'unknown';
+
+  return projectTech(framework === 'unknown' ? 'service' : 'backend', 'bundler', framework, ['Ruby']);
+}
+
+function detectJavaProject(dir) {
+  if (!hasAnyFile(dir, ['pom.xml', 'build.gradle', 'build.gradle.kts'])) return null;
+
+  const javaConfig = [
+    readIfExists(path.join(dir, 'pom.xml')),
+    readIfExists(path.join(dir, 'build.gradle')),
+    readIfExists(path.join(dir, 'build.gradle.kts'))
+  ].join('\n').toLowerCase();
+
+  const pm = fs.existsSync(path.join(dir, 'pom.xml')) ? 'maven' : 'gradle';
+  const framework = javaConfig.includes('spring') ? 'spring' : 'java';
+  return projectTech('backend', pm, framework, ['Java']);
+}
+
+function detectDotnetProject(dir) {
+  const hasDotnetFile = fs.readdirSync(dir).some((entry) => entry.endsWith('.csproj') || entry.endsWith('.sln'));
+  return hasDotnetFile ? projectTech('backend', 'dotnet', 'dotnet', ['C#']) : null;
+}
+
+function detectDartProject(dir) {
+  if (!fs.existsSync(path.join(dir, 'pubspec.yaml'))) return null;
+
+  const pubspec = readIfExists(path.join(dir, 'pubspec.yaml')).toLowerCase();
+  const framework = pubspec.includes('flutter:') ? 'flutter' : 'dart';
+  return projectTech(framework === 'flutter' ? 'mobile' : 'service', 'pub', framework, ['Dart']);
+}
+
+function guessRoleAndTech(dir) {
+  const detectors = [
+    detectJavaScriptProject,
+    detectPythonProject,
+    (projectDir) => fs.existsSync(path.join(projectDir, 'Cargo.toml')) ? projectTech('service', 'cargo', 'rust', ['Rust']) : null,
+    detectComposerProject,
+    detectRubyProject,
+    detectJavaProject,
+    (projectDir) => fs.existsSync(path.join(projectDir, 'go.mod')) ? projectTech('backend', 'go mod', 'go', ['Go']) : null,
+    detectDotnetProject,
+    detectDartProject
+  ];
+
+  return detectors.map((detect) => detect(dir)).find(Boolean) ?? projectTech('unknown', 'unknown', 'unknown', []);
+}
+
+function generateWorkspaceMap() {
+  if (!workspaceMode || !workspaceData) return;
+  const projectDir = path.join(target, '.agent-os', 'project');
+  ensureDir(projectDir);
+  const mapFile = path.join(projectDir, 'WORKSPACE_MAP.md');
+  
+  let md = `# Agent OS Workspace Map\n\n`;
+  md += `- **Workspace Name**: ${workspaceData.name}\n`;
+  md += `- **Workspace File**: ${workspaceData.file}\n`;
+  md += `- **Install Root**: ${target}\n\n`;
+  md += `## Detected Folders\n\n`;
+  
+  for (const f of workspaceData.folders) {
+    const tech = guessRoleAndTech(f.path);
+    md += `### ${f.name}\n`;
+    md += `- **Absolute Path**: ${f.path}\n`;
+    md += `- **Probable Role**: ${tech.role}\n`;
+    md += `- **Languages**: ${tech.languages.length > 0 ? tech.languages.join(', ') : 'unknown'}\n`;
+    md += `- **Package Manager**: ${tech.pm}\n`;
+    md += `- **Framework**: ${tech.framework}\n\n`;
+  }
+  
+  if (!isDryRun) {
+    fs.writeFileSync(mapFile, md);
+    rollbackLog.push({ type: 'copy', dest: mapFile, backup: null });
+  }
+  log(`Generated WORKSPACE_MAP.md for ${workspaceData.name}`, true);
+}
+
+function updateWorkspaceFile() {
+  if (!workspaceMode || !workspaceData?.json) return;
+  
+  const absWorkspaceFile = workspaceData.file;
+  const workspaceDir = path.dirname(absWorkspaceFile);
+  let relativePath = path.relative(workspaceDir, target).split(path.sep).join('/');
+  if (relativePath === '') relativePath = '.';
+  
+  const newEntry = { name: "agent-os", path: relativePath };
+  
+  const existing = workspaceData.json.folders.find(f => f.name === newEntry.name || f.path === newEntry.path);
+  
+  if (existing) {
+    log(`Agent OS folder already exists in workspace file. Skipping update.`, true);
+    return;
+  }
+  
+  if (isVerbose) {
+    log(`[VERBOSE] Workspace folders before update:\n${JSON.stringify(workspaceData.json.folders, null, 2)}`);
+  }
+  
+  workspaceData.json.folders.push(newEntry);
+  
+  if (isVerbose) {
+    log(`[VERBOSE] Workspace folders after update:\n${JSON.stringify(workspaceData.json.folders, null, 2)}`);
+    log(`[VERBOSE] Added Agent OS path: ${relativePath}`);
+  }
+  
+  if (!isDryRun) {
+    let bp = null;
+    if (doBackup && fs.existsSync(absWorkspaceFile)) {
+      bp = `${absWorkspaceFile}.bak_${Date.now()}`;
+      fs.copyFileSync(absWorkspaceFile, bp);
+      log(`Backed up workspace file: ${absWorkspaceFile} -> ${bp}`, true);
+      stats.workspaceFileBackupPath = bp;
+    }
+    fs.writeFileSync(absWorkspaceFile, JSON.stringify(workspaceData.json, null, 2));
+    rollbackLog.push({ type: 'copy', dest: absWorkspaceFile, backup: bp });
+  }
+  
+  log(`Workspace file updated`, true);
+  log(`Agent OS folder added to workspace`, true);
+  
+  stats.workspaceFileUpdated = true;
+  stats.agentOsWorkspaceEntry = newEntry;
+}
+
+function validateAdapterTarget(adapterDir) {
+  if (!fs.existsSync(path.join(target, adapterDir))) {
+    log(`[WARN] Target workspace does not seem to contain ${adapterDir}. Installing anyway.`);
+  }
+}
+
+function installAdapter(adapter) {
+  const map = {
+    codex: () => {
+      validateAdapterTarget('.codex');
+      copyRecursive(path.join(repoRoot, 'skills'), path.join(target, '.codex', 'skills'));
+    },
+    cursor: () => {
+      validateAdapterTarget('.cursor');
+      ensureDir(path.join(target, '.cursor', 'rules'));
+      copyFile(path.join(repoRoot, 'adapters', 'cursor', 'agent-os.rules.md'), path.join(target, '.cursor', 'rules', 'agent-os.md'));
+    },
+    claude: () => {
+      copyFile(path.join(repoRoot, 'adapters', 'claude', 'CLAUDE.md'), path.join(target, 'CLAUDE.md'));
+    },
+    antigravity: () => {
+      ensureDir(path.join(target, '.antigravity-plugin'));
+      copyFile(path.join(repoRoot, 'adapters', 'antigravity', 'plugin.json'), path.join(target, '.antigravity-plugin', 'plugin.json'));
+    },
+    fallback: () => {
+      const dest = path.join(target, '.agent');
+      ensureDir(dest);
+      const fallbackPath = path.join(dest, 'README.md');
+      let bp = null;
+      if (!isDryRun) {
+        if (fs.existsSync(fallbackPath)) { bp = backupFile(fallbackPath); stats.overwritten++; }
+        else { stats.copied++; }
+        fs.writeFileSync(fallbackPath, `# Agent OS Fallback\n\nLoad ../.agent-os/ENTRYPOINT.md.\n`);
+        rollbackLog.push({ type: 'copy', dest: fallbackPath, backup: bp });
+      }
+      log(`Generated Universal Fallback: ${fallbackPath}`, true);
+    }
+  };
+  
+  if (map[adapter]) map[adapter]();
+}
+
+try {
+  installAgentOS();
+  generateWorkspaceMap();
+  updateWorkspaceFile();
+  
+  if (hasFlag('--all')) {
+    ['codex', 'cursor', 'claude', 'antigravity', 'fallback'].forEach(installAdapter);
+  } else {
+    if (hasFlag('--codex')) installAdapter('codex');
+    if (hasFlag('--cursor')) installAdapter('cursor');
+    if (hasFlag('--claude')) installAdapter('claude');
+    if (hasFlag('--antigravity')) installAdapter('antigravity');
+    if (hasFlag('--fallback')) installAdapter('fallback');
+  }
+
+  log('\n=== Installation Summary ===');
+  log(`Target: ${target}`);
+  if (workspaceMode) {
+    log(`Workspace Name: ${workspaceData.name}`);
+    log(`Workspace File: ${workspaceData.file}`);
+    log(`Resolved Folders: ${workspaceData.folders.length}`);
+  }
+  log(`Version: v${CURRENT_VERSION}`);
+  log(`Copied: ${stats.copied}`);
+  log(`Overwritten: ${stats.overwritten}`);
+  log(`Backed Up: ${stats.backedUp}`);
+  log(`Skipped: ${stats.skipped}`);
+  log(`Conflicts: ${stats.conflicts}`);
+  log(`Errors: ${stats.errors}`);
+
+  if (stats.errors > 0 && !force) {
+    log('Installation failed due to errors. Rollback should have occurred.');
+  } else if (isDryRun) {
+    log('SUCCESS (DRY RUN): No files were changed.');
+  } else {
+    log('SUCCESS: Agent OS installed securely.');
+    fs.writeFileSync(path.join(target, 'install-report.json'), JSON.stringify(stats, null, 2));
+  }
+
+} catch (e) {
+  logError(`Unhandled exception during install: ${e.message}`);
+}
+
+if (logStream) logStream.end();