convoke-agents 2.0.0

package/scripts/install-vortex-agents.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const { refreshInstallation } = require('./update/lib/refresh-installation');
+const { findProjectRoot } = require('./update/lib/utils');
+const { AGENTS } = require('./update/lib/agent-registry');
+
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+const GREEN = '\x1b[32m';
+const CYAN = '\x1b[36m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const GREY = '\x1b[90m';
+
+function printBanner() {
+  console.log('');
+  console.log(`${GREY}  ██████╗ ██████╗ ███╗   ██╗██╗   ██╗ ██████╗ ██╗  ██╗███████╗${RESET}`);
+  console.log(`${GREY} ██╔════╝██╔═══██╗████╗  ██║██║   ██║██╔═══██╗██║ ██╔╝██╔════╝${RESET}`);
+  console.log(`${GREY} ██║     ██║   ██║██╔██╗ ██║██║   ██║██║   ██║█████╔╝ █████╗  ${RESET}`);
+  console.log(`${GREY} ██║     ██║   ██║██║╚██╗██║╚██╗ ██╔╝██║   ██║██╔═██╗ ██╔══╝  ${RESET}`);
+  console.log(`${GREY} ╚██████╗╚██████╔╝██║ ╚████║ ╚████╔╝ ╚██████╔╝██║  ██╗███████╗${RESET}`);
+  console.log(`${GREY}  ╚═════╝ ╚═════╝ ╚═╝  ╚═══╝  ╚═══╝   ╚═════╝ ╚═╝  ╚═╝╚══════╝${RESET}`);
+  console.log(`${GREY}       Agent teams for complex systems${RESET}`);
+  console.log('');
+  console.log(`${BOLD} Domain-specialized agent teams | compatible with BMAD Method${RESET}`);
+  console.log('');
+}
+
+function checkPrerequisites(projectRoot) {
+  console.log(`${CYAN}[1/6]${RESET} Checking prerequisites...`);
+
+  const bmadDir = path.join(projectRoot, '_bmad');
+
+  // Create _bmad directory if it doesn't exist
+  if (!fs.existsSync(bmadDir)) {
+    console.log(`${YELLOW}  ⚠${RESET} _bmad directory not found - creating it`);
+    fs.mkdirSync(bmadDir, { recursive: true });
+  } else {
+    console.log(`${GREEN}  ✓${RESET} BMAD directory detected`);
+  }
+
+  // Check for BMAD Method configuration (optional)
+  const bmadConfigPath = path.join(bmadDir, '_config', 'bmad.yaml');
+  if (fs.existsSync(bmadConfigPath)) {
+    console.log(`${GREEN}  ✓${RESET} BMAD Method configuration found`);
+  } else {
+    console.log(`${YELLOW}  ⚠${RESET} BMAD Method not detected (Convoke will install standalone)`);
+  }
+
+  console.log(`${GREEN}  ✓${RESET} Prerequisites met`);
+}
+
+function archiveDeprecatedWorkflows(projectRoot) {
+  console.log(`${CYAN}[2/6]${RESET} Archiving deprecated workflows...`);
+
+  const sourceDir = path.join(__dirname, '..', '_bmad', 'bme', '_vortex');
+  const targetDir = path.join(projectRoot, '_bmad', 'bme', '_vortex');
+
+  // Only wireframe is deprecated now; empathy-map is live for Isla
+  const deprecatedWorkflows = ['wireframe'];
+
+  for (const workflow of deprecatedWorkflows) {
+    const workflowSourceDir = path.join(sourceDir, 'workflows', '_deprecated', workflow);
+    const workflowTargetDir = path.join(targetDir, 'workflows', '_deprecated', workflow);
+
+    if (fs.existsSync(workflowSourceDir)) {
+      fs.copySync(workflowSourceDir, workflowTargetDir);
+      console.log(`${GREEN}  ✓${RESET} Archived ${workflow} to _deprecated/`);
+    }
+  }
+
+  // Legacy cleanup
+  cleanupLegacyFiles(projectRoot);
+}
+
+function cleanupLegacyFiles(projectRoot) {
+  console.log(`${CYAN}  →${RESET} Cleaning up legacy files...`);
+
+  // Remove _designos directory (pre-Vortex structure) from all possible locations
+  const legacyPaths = [
+    path.join(projectRoot, '_bmad', 'bme', '_designos'),
+    path.join(projectRoot, '_bmad', '_designos'),
+  ];
+
+  for (const legacyPath of legacyPaths) {
+    if (fs.existsSync(legacyPath)) {
+      fs.removeSync(legacyPath);
+      console.log(`${GREEN}    ✓${RESET} Removed legacy directory: ${path.relative(projectRoot, legacyPath)}`);
+    }
+  }
+
+  console.log(`${GREEN}  ✓${RESET} Legacy cleanup complete`);
+}
+
+function csvEscape(value) {
+  return `"${String(value).replace(/"/g, '""')}"`;
+}
+
+function createAgentManifest(projectRoot) {
+  console.log(`${CYAN}[3/6]${RESET} Creating agent manifest...`);
+
+  const manifestPath = path.join(projectRoot, '_bmad', '_config', 'agent-manifest.csv');
+  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+
+  const header = '"agent_id","name","title","icon","role","identity","communication_style","expertise","submodule","path"\n';
+  const rows = AGENTS.map(a => {
+    const p = a.persona;
+    return [
+      a.id, a.name, a.title, a.icon,
+      p.role, p.identity, p.communication_style, p.expertise,
+      'bme', `_bmad/bme/_vortex/agents/${a.id}.md`,
+    ].map(csvEscape).join(',');
+  }).join('\n') + '\n';
+
+  fs.writeFileSync(manifestPath, header + rows);
+  console.log(`${GREEN}  ✓${RESET} Created agent-manifest.csv`);
+}
+
+function createOutputDirectory(projectRoot) {
+  console.log(`${CYAN}[4/6]${RESET} Setting up output directory...`);
+
+  const outputDir = path.join(projectRoot, '_bmad-output', 'vortex-artifacts');
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  console.log(`${GREEN}  ✓${RESET} Output directory ready`);
+}
+
+function verifyInstallation(projectRoot) {
+  console.log(`${CYAN}[6/6]${RESET} Verifying installation...`);
+
+  const checks = [
+    ...AGENTS.map(a => ({ path: `_bmad/bme/_vortex/agents/${a.id}.md`, name: `${a.name} agent file` })),
+    { path: '_bmad/bme/_vortex/config.yaml', name: 'Configuration file' },
+  ];
+
+  let allChecksPass = true;
+  checks.forEach(check => {
+    const fullPath = path.join(projectRoot, check.path);
+    if (fs.existsSync(fullPath)) {
+      console.log(`${GREEN}  ✓${RESET} ${check.name}`);
+    } else {
+      console.log(`${RED}  ✗${RESET} ${check.name} - MISSING`);
+      allChecksPass = false;
+    }
+  });
+
+  if (!allChecksPass) {
+    console.log('');
+    console.error(`${RED}Installation verification failed. Some files are missing.${RESET}`);
+    process.exit(1);
+  }
+
+  console.log(`${GREEN}  ✓${RESET} All files installed successfully`);
+}
+
+function printSuccess() {
+  console.log('');
+  console.log(`${GREEN}${BOLD}╔════════════════════════════════════════════════════╗${RESET}`);
+  console.log(`${GREEN}${BOLD}║                                                    ║${RESET}`);
+  console.log(`${GREEN}${BOLD}║    ✓  All Vortex Agents Installed! 🎉             ║${RESET}`);
+  console.log(`${GREEN}${BOLD}║                                                    ║${RESET}`);
+  console.log(`${GREEN}${BOLD}╚════════════════════════════════════════════════════╝${RESET}`);
+  console.log('');
+  console.log(`${BOLD}Installed Agents:${RESET}`);
+  console.log('');
+  for (const agent of AGENTS) {
+    console.log(`  ${GREEN}✓${RESET} ${agent.name} (${agent.id}) - ${agent.title} ${agent.icon}`);
+  }
+  console.log('');
+  console.log(`${BOLD}Next Steps:${RESET}`);
+  console.log('');
+  console.log(`  ${YELLOW}1.${RESET} Personalize your config:`);
+  console.log(`     Edit ${CYAN}_bmad/bme/_vortex/config.yaml${RESET} and replace ${YELLOW}{user}${RESET} with your name`);
+  console.log('');
+  console.log(`  ${YELLOW}2.${RESET} Activate an agent by reading their file:`);
+  for (const agent of AGENTS) {
+    console.log(`     ${CYAN}cat _bmad/bme/_vortex/agents/${agent.id}.md${RESET}  (${agent.name})`);
+  }
+  console.log('');
+}
+
+async function main() {
+  try {
+    // Use findProjectRoot for existing projects, fall back to cwd for fresh installs
+    const projectRoot = findProjectRoot() || process.cwd();
+
+    printBanner();
+    checkPrerequisites(projectRoot);
+    archiveDeprecatedWorkflows(projectRoot);
+    createAgentManifest(projectRoot);
+    createOutputDirectory(projectRoot);
+
+    // Use refreshInstallation for agents, workflows, config, and user guides
+    console.log(`${CYAN}[5/6]${RESET} Installing agents, workflows, config, and guides...`);
+    await refreshInstallation(projectRoot, { backupGuides: false });
+    console.log(`${GREEN}  ✓${RESET} Installation refreshed`);
+
+    verifyInstallation(projectRoot);
+    printSuccess();
+  } catch (error) {
+    console.error(`${RED}✗ Installation failed:${RESET}`, error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/postinstall.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const fs = require('fs');
+const { AGENTS } = require('./update/lib/agent-registry');
+
+// Check if update system is available
+const versionDetectorPath = path.join(__dirname, 'update/lib/version-detector.js');
+const registryPath = path.join(__dirname, 'update/migrations/registry.js');
+
+const hasUpdateSystem = fs.existsSync(versionDetectorPath) && fs.existsSync(registryPath);
+
+// ANSI color codes
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+
+async function main() {
+  console.log('');
+  console.log(`${BOLD}Convoke installed!${RESET}`);
+  console.log('');
+
+  // If update system available, check for upgrades
+  if (hasUpdateSystem) {
+    const versionDetector = require('./update/lib/version-detector');
+    const registry = require('./update/migrations/registry');
+
+    const { findProjectRoot, compareVersions } = require('./update/lib/utils');
+    const projectRoot = findProjectRoot();
+
+    const currentVersion = versionDetector.getCurrentVersion(projectRoot);
+    const targetVersion = versionDetector.getTargetVersion();
+    const scenario = versionDetector.detectInstallationScenario(projectRoot);
+
+    // Fresh install
+    if (scenario === 'fresh' || !currentVersion) {
+      const agentNames = AGENTS.map(a => a.name).join(' + ');
+      console.log('To install agents into your project, run:');
+      console.log('');
+      console.log(`  ${CYAN}npx convoke-install${RESET}  - Install all agents (${agentNames})`);
+      console.log('');
+      return;
+    }
+
+    // Already up to date
+    if (currentVersion === targetVersion) {
+      console.log(`${GREEN}✓ Convoke is up to date! (v${currentVersion})${RESET}`);
+      console.log('');
+      return;
+    }
+
+    // Upgrade detected
+    if (compareVersions(currentVersion, targetVersion) < 0) {
+      console.log(`${YELLOW}${BOLD}⚠ UPGRADE DETECTED${RESET}`);
+      console.log('');
+      console.log(`  Current version: ${RED}${currentVersion}${RESET}`);
+      console.log(`  New version:     ${GREEN}${targetVersion}${RESET}`);
+      console.log('');
+
+      // Check for breaking changes
+      const breakingChanges = registry.getBreakingChanges(currentVersion);
+      if (breakingChanges.length > 0) {
+        console.log(`${RED}${BOLD}  ⚠ Breaking changes detected!${RESET}`);
+        console.log('');
+        console.log('  Breaking changes:');
+        breakingChanges.forEach(change => {
+          console.log(`${YELLOW}    - ${change}${RESET}`);
+        });
+        console.log('');
+      }
+
+      console.log('To preview changes without applying:');
+      console.log(`  ${CYAN}npx convoke-update --dry-run${RESET}`);
+      console.log('');
+      console.log('To apply the update:');
+      console.log(`  ${CYAN}npx convoke-update${RESET}`);
+      console.log('');
+      console.log(`${BOLD}Your data will be backed up automatically before any changes.${RESET}`);
+      console.log('');
+      return;
+    }
+
+    // Downgrade (shouldn't happen normally)
+    if (compareVersions(currentVersion, targetVersion) > 0) {
+      console.log(`${YELLOW}Note: Package version (${targetVersion}) is older than installed version (${currentVersion})${RESET}`);
+      console.log('');
+      return;
+    }
+  } else {
+    // Fallback to original message if update system not available
+    const agentNames = AGENTS.map(a => a.name).join(' + ');
+    console.log('To install agents into your project, run:');
+    console.log('');
+    console.log(`  ${CYAN}npx convoke-install${RESET}  - Install all agents (${agentNames})`);
+    console.log('');
+  }
+}
+
+main().catch(error => {
+  console.error('Error in postinstall:', error.message);
+});

package/scripts/update/convoke-migrate.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+const chalk = require('chalk');
+const registry = require('./migrations/registry');
+const backupManager = require('./lib/backup-manager');
+const { refreshInstallation } = require('./lib/refresh-installation');
+const { findProjectRoot } = require('./lib/utils');
+
+/**
+ * Convoke Migrate CLI
+ * Manual migration control for advanced users
+ */
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Validate project root
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.error('');
+    console.error(chalk.red('Not in a Convoke project. Could not find _bmad/ directory.'));
+    console.error('');
+    process.exit(1);
+  }
+
+  // No args - show available migrations
+  if (args.length === 0) {
+    showAvailableMigrations();
+    return;
+  }
+
+  const migrationName = args[0];
+
+  // Find migration
+  const migrations = registry.getAllMigrations();
+  const migration = migrations.find(m => m.name === migrationName);
+
+  if (!migration) {
+    console.error('');
+    console.error(chalk.red(`Migration '${migrationName}' not found.`));
+    console.error('');
+    console.error('Run ' + chalk.cyan('npx convoke-migrate') + ' to see available migrations.');
+    console.error('');
+    process.exit(1);
+  }
+
+  // Check if already applied
+  const configPath = require('path').join(projectRoot, '_bmad/bme/_vortex/config.yaml');
+  if (registry.hasMigrationBeenApplied(migrationName, configPath)) {
+    console.log('');
+    console.log(chalk.yellow(`Migration '${migrationName}' has already been applied.`));
+    console.log('');
+    process.exit(0);
+  }
+
+  // Load migration module
+  if (!migration.module) {
+    try {
+      migration.module = require(`./migrations/${migration.name}`);
+    } catch (error) {
+      console.error('');
+      console.error(chalk.red(`Failed to load migration: ${error.message}`));
+      console.error('');
+      process.exit(1);
+    }
+  }
+
+  // Run migration with backup and refresh
+  console.log('');
+  console.log(chalk.cyan.bold(`Running migration: ${migration.name}`));
+  console.log(chalk.gray(migration.description));
+  console.log('');
+
+  let backupMetadata = null;
+
+  try {
+    // Create backup before running delta
+    console.log(chalk.cyan('Creating backup...'));
+    backupMetadata = await backupManager.createBackup('manual', projectRoot);
+    console.log(chalk.green(`✓ Backup created: ${require('path').basename(backupMetadata.backup_dir)}`));
+    console.log('');
+
+    // Run the delta
+    const changes = await migration.module.apply(projectRoot);
+
+    console.log('');
+    console.log(chalk.green.bold('✓ Migration delta completed'));
+    console.log('');
+    console.log(chalk.cyan('Delta changes:'));
+    changes.forEach(change => {
+      console.log(chalk.gray(`  - ${change}`));
+    });
+    console.log('');
+
+    // Refresh installation after delta
+    console.log(chalk.cyan('Refreshing installation files...'));
+    await refreshInstallation(projectRoot);
+    console.log(chalk.green('✓ Installation refreshed'));
+    console.log('');
+
+  } catch (error) {
+    console.error('');
+    console.error(chalk.red.bold('✗ Migration failed'));
+    console.error(chalk.red(error.message));
+    console.error('');
+
+    // Rollback if we have a backup
+    if (backupMetadata) {
+      console.log(chalk.yellow('Restoring from backup...'));
+      try {
+        await backupManager.restoreBackup(backupMetadata, projectRoot);
+        console.log(chalk.green('✓ Installation restored from backup'));
+        console.log('');
+      } catch (restoreError) {
+        console.error(chalk.red('✗ Restore failed!'));
+        console.error(chalk.red(restoreError.message));
+        console.error('');
+        console.error(chalk.yellow(`Manual restore may be needed from: ${backupMetadata.backup_dir}`));
+        console.error('');
+      }
+    }
+
+    if (error.stack) {
+      console.error(chalk.gray(error.stack));
+      console.error('');
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Show available migrations
+ */
+function showAvailableMigrations() {
+  const migrations = registry.getAllMigrations();
+
+  console.log('');
+  console.log(chalk.bold('Available Migrations'));
+  console.log('');
+
+  if (migrations.length === 0) {
+    console.log(chalk.yellow('No migrations available'));
+    console.log('');
+    return;
+  }
+
+  migrations.forEach((m, index) => {
+    const breaking = m.breaking ? chalk.red('[BREAKING]') : chalk.green('[SAFE]');
+    console.log(`  ${index + 1}. ${chalk.cyan(m.name)} ${breaking}`);
+    console.log(`     ${chalk.gray(m.description)}`);
+    console.log(`     ${chalk.gray(`From: ${m.fromVersion}`)}`);
+    console.log('');
+  });
+
+  console.log('Usage: ' + chalk.cyan('npx convoke-migrate <migration-name>'));
+  console.log('');
+  console.log(chalk.yellow('Warning: Manual migrations bypass safety checks.'));
+  console.log(chalk.yellow('         Use ' + chalk.cyan('npx convoke-update') + ' for normal updates.'));
+  console.log('');
+}
+
+// Run main
+main().catch(error => {
+  console.error('');
+  console.error(chalk.red('Unexpected error:'));
+  console.error(chalk.red(error.message));
+  console.error('');
+  process.exit(1);
+});