aios-core 3.1.0 → 3.2.0

package/bin/aios-init.js

@@ -60,6 +60,15 @@ const { detectRepositoryContext } = resolveAiosCoreModule('scripts/repository-de
 // const { GitHubProjectsAdapter } = resolveAiosCoreModule('utils/pm-adapters/github-adapter');
 // const { JiraAdapter } = resolveAiosCoreModule('utils/pm-adapters/jira-adapter');
 
+// Brownfield upgrade module (Story 6.18)
+let brownfieldUpgrader;
+try {
+  brownfieldUpgrader = require('../src/installer/brownfield-upgrader');
+} catch (_err) {
+  // Module may not be available in older installations
+  brownfieldUpgrader = null;
+}
+
 async function main() {
   console.clear();
 
@@ -142,6 +151,108 @@ async function main() {
   console.log(chalk.cyan('📦 Package:') + ` ${context.packageName}`);
   console.log('');
 
+  // Check for existing installation (Story 6.18 - Brownfield Upgrade)
+  const installedManifestPath = path.join(projectRoot, '.aios-core', '.installed-manifest.yaml');
+  const hasExistingInstall = fs.existsSync(installedManifestPath);
+
+  if (hasExistingInstall && brownfieldUpgrader) {
+    console.log(chalk.yellow('🔄 Existing AIOS installation detected!'));
+    console.log('');
+
+    const sourceDir = path.join(context.frameworkLocation, '.aios-core');
+    const upgradeCheck = brownfieldUpgrader.checkUpgradeAvailable(sourceDir, projectRoot);
+
+    if (upgradeCheck.available) {
+      console.log(chalk.green(`   Upgrade available: ${upgradeCheck.from} → ${upgradeCheck.to}`));
+      console.log('');
+
+      // Generate upgrade report for display
+      const sourceManifest = brownfieldUpgrader.loadSourceManifest(sourceDir);
+      const installedManifest = brownfieldUpgrader.loadInstalledManifest(projectRoot);
+      const report = brownfieldUpgrader.generateUpgradeReport(sourceManifest, installedManifest, projectRoot);
+
+      console.log(chalk.gray('─'.repeat(80)));
+      const { upgradeChoice } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'upgradeChoice',
+          message: chalk.white('What would you like to do?'),
+          choices: [
+            {
+              name: `  Upgrade to ${upgradeCheck.to} ` + chalk.gray(`(${report.newFiles.length} new, ${report.modifiedFiles.length} updated files)`),
+              value: 'upgrade',
+            },
+            {
+              name: '  Dry Run ' + chalk.gray('(Show what would be changed without applying)'),
+              value: 'dry-run',
+            },
+            {
+              name: '  Fresh Install ' + chalk.gray('(Reinstall everything, overwrite all files)'),
+              value: 'fresh',
+            },
+            {
+              name: '  Cancel ' + chalk.gray('(Exit without changes)'),
+              value: 'cancel',
+            },
+          ],
+        },
+      ]);
+
+      if (upgradeChoice === 'cancel') {
+        console.log(chalk.yellow('\nInstallation cancelled.'));
+        process.exit(0);
+      }
+
+      if (upgradeChoice === 'dry-run') {
+        console.log('');
+        console.log(brownfieldUpgrader.formatUpgradeReport(report));
+        console.log('');
+        console.log(chalk.yellow('This was a dry run. No files were changed.'));
+        console.log(chalk.gray('Run again and select "Upgrade" to apply changes.'));
+        process.exit(0);
+      }
+
+      if (upgradeChoice === 'upgrade') {
+        console.log('');
+        console.log(chalk.blue('📦 Applying upgrade...'));
+
+        const result = await brownfieldUpgrader.applyUpgrade(report, sourceDir, projectRoot, { dryRun: false });
+
+        if (result.success) {
+          // Update installed manifest
+          const packageJson = require(path.join(context.frameworkLocation, 'package.json'));
+          brownfieldUpgrader.updateInstalledManifest(projectRoot, sourceManifest, `aios-core@${packageJson.version}`);
+
+          console.log(chalk.green('✓') + ` Upgraded ${result.filesInstalled.length} files`);
+          if (result.filesSkipped.length > 0) {
+            console.log(chalk.yellow('⚠') + ` Preserved ${result.filesSkipped.length} user-modified files`);
+          }
+          console.log('');
+          console.log(chalk.green('✅ Upgrade complete!'));
+          console.log(chalk.gray(`   From: ${upgradeCheck.from}`));
+          console.log(chalk.gray(`   To:   ${upgradeCheck.to}`));
+          process.exit(0);
+        } else {
+          console.error(chalk.red('✗') + ' Upgrade failed with errors:');
+          for (const err of result.errors) {
+            console.error(chalk.red(`   - ${err.path}: ${err.error}`));
+          }
+          process.exit(1);
+        }
+      }
+
+      // If 'fresh' was selected, continue with normal installation flow below
+      if (upgradeChoice === 'fresh') {
+        console.log(chalk.yellow('\nProceeding with fresh installation...'));
+        console.log('');
+      }
+    } else {
+      console.log(chalk.green(`   Current version: ${upgradeCheck.from || 'unknown'}`));
+      console.log(chalk.gray('   No upgrade available. You can proceed with fresh install if needed.'));
+      console.log('');
+    }
+  }
+
   // Step 1: Installation Mode
   console.log(chalk.gray('─'.repeat(80)));
   const { installMode } = await inquirer.prompt([
@@ -251,6 +362,21 @@ async function main() {
   if (fs.existsSync(sourceCoreDir)) {
     await fse.copy(sourceCoreDir, targetCoreDir);
     console.log(chalk.green('✓') + ' AIOS Core files installed ' + chalk.gray('(11 agents, 68 tasks, 23 templates)'));
+
+    // Create installed manifest for brownfield upgrades (Story 6.18)
+    if (brownfieldUpgrader) {
+      try {
+        const sourceManifest = brownfieldUpgrader.loadSourceManifest(sourceCoreDir);
+        if (sourceManifest) {
+          const packageJson = require(path.join(context.frameworkLocation, 'package.json'));
+          brownfieldUpgrader.updateInstalledManifest(context.projectRoot, sourceManifest, `aios-core@${packageJson.version}`);
+          console.log(chalk.green('✓') + ' Installation manifest created ' + chalk.gray('(enables future upgrades)'));
+        }
+      } catch (manifestErr) {
+        // Non-critical - just log warning
+        console.log(chalk.yellow('⚠') + ' Could not create installation manifest ' + chalk.gray('(brownfield upgrades may not work)'));
+      }
+    }
   } else {
     console.error(chalk.red('✗') + ' AIOS Core files not found');
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aios-core",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Synkra AIOS: AI-Orchestrated System for Full Stack Development - Core Framework",
   "main": "index.js",
   "module": "index.esm.js",
@@ -78,6 +78,9 @@
     "version:expansion:all:patch": "node tools/bump-all-versions.js patch",
     "release": "semantic-release",
     "release:test": "semantic-release --dry-run --no-ci || echo 'Config test complete - authentication errors are expected locally'",
+    "generate:manifest": "node scripts/generate-install-manifest.js",
+    "validate:manifest": "node scripts/validate-manifest.js",
+    "prepublishOnly": "npm run generate:manifest && npm run validate:manifest",
     "prepare": "echo 'Skipping husky - not needed for NPM publish'"
   },
   "dependencies": {

package/scripts/generate-install-manifest.js

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+/**
+ * Generate Install Manifest
+ * Dynamically generates install-manifest.yaml with file hashes for brownfield upgrades
+ *
+ * @script scripts/generate-install-manifest.js
+ * @story 6.18 - Dynamic Manifest & Brownfield Upgrade System
+ *
+ * Usage:
+ *   node scripts/generate-install-manifest.js
+ *   npm run generate:manifest
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+const { hashFile, hashString } = require('../src/installer/file-hasher');
+
+// Import FOLDERS_TO_COPY from installer (same source of truth)
+const FOLDERS_TO_COPY = [
+  // v2.1 Modular Structure
+  'core',
+  'development',
+  'product',
+  'infrastructure',
+  // v2.0 Legacy Flat Structure (backwards compatibility)
+  'agents',
+  'agent-teams',
+  'checklists',
+  'data',
+  'docs',
+  'elicitation',
+  'scripts',
+  'tasks',
+  'templates',
+  'tools',
+  'workflows',
+  // Additional directories
+  'cli',
+  'manifests',
+];
+
+const ROOT_FILES_TO_COPY = [
+  'index.js',
+  'index.esm.js',
+  'index.d.ts',
+  'core-config.yaml',
+  'package.json',
+  'user-guide.md',
+  'working-in-the-brownfield.md',
+];
+
+// Files/folders to exclude from manifest
+const EXCLUDE_PATTERNS = [
+  /node_modules/,
+  /\.git/,
+  /\.DS_Store/,
+  /Thumbs\.db/,
+  /\.installed-manifest\.yaml$/,  // Don't include installed manifest
+  /\.bak$/,
+  /\.tmp$/,
+  /~$/,
+];
+
+/**
+ * Check if a path should be excluded
+ * @param {string} filePath - Path to check
+ * @returns {boolean} - True if should be excluded
+ */
+function shouldExclude(filePath) {
+  return EXCLUDE_PATTERNS.some(pattern => pattern.test(filePath));
+}
+
+/**
+ * Determine file type based on path
+ * @param {string} relativePath - Relative file path
+ * @returns {string} - File type identifier
+ */
+function getFileType(relativePath) {
+  const normalized = relativePath.replace(/\\/g, '/');
+
+  if (normalized.includes('/agents/') || normalized.startsWith('agents/')) {
+    return 'agent';
+  }
+  if (normalized.includes('/tasks/') || normalized.startsWith('tasks/')) {
+    return 'task';
+  }
+  if (normalized.includes('/workflows/') || normalized.startsWith('workflows/')) {
+    return 'workflow';
+  }
+  if (normalized.includes('/templates/') || normalized.startsWith('templates/')) {
+    return 'template';
+  }
+  if (normalized.includes('/checklists/') || normalized.startsWith('checklists/')) {
+    return 'checklist';
+  }
+  if (normalized.includes('/scripts/') || normalized.startsWith('scripts/')) {
+    return 'script';
+  }
+  if (normalized.includes('/tools/') || normalized.startsWith('tools/')) {
+    return 'tool';
+  }
+  if (normalized.includes('/data/') || normalized.startsWith('data/')) {
+    return 'data';
+  }
+  if (normalized.includes('/docs/') || normalized.startsWith('docs/')) {
+    return 'documentation';
+  }
+  if (normalized.includes('/elicitation/') || normalized.startsWith('elicitation/')) {
+    return 'elicitation';
+  }
+  if (normalized.includes('/manifests/') || normalized.startsWith('manifests/')) {
+    return 'manifest';
+  }
+  if (normalized.includes('/cli/') || normalized.startsWith('cli/')) {
+    return 'cli';
+  }
+  if (normalized.includes('/core/') || normalized.startsWith('core/')) {
+    return 'core';
+  }
+  if (normalized.includes('/infrastructure/') || normalized.startsWith('infrastructure/')) {
+    return 'infrastructure';
+  }
+  if (normalized.includes('/product/') || normalized.startsWith('product/')) {
+    return 'product';
+  }
+  if (normalized.includes('/development/') || normalized.startsWith('development/')) {
+    return 'development';
+  }
+
+  // Root files
+  if (normalized.endsWith('.js') || normalized.endsWith('.ts')) {
+    return 'code';
+  }
+  if (normalized.endsWith('.yaml') || normalized.endsWith('.yml')) {
+    return 'config';
+  }
+  if (normalized.endsWith('.md')) {
+    return 'documentation';
+  }
+
+  return 'other';
+}
+
+/**
+ * Recursively scan directory and collect file metadata
+ * @param {string} dirPath - Directory to scan
+ * @param {string} basePath - Base path for relative paths
+ * @param {string[]} files - Array to collect files
+ */
+function scanDirectory(dirPath, basePath, files = []) {
+  if (!fs.existsSync(dirPath)) {
+    return files;
+  }
+
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    const relativePath = path.relative(basePath, fullPath).replace(/\\/g, '/');
+
+    if (shouldExclude(relativePath)) {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      scanDirectory(fullPath, basePath, files);
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Generate the install manifest
+ * @returns {Object} - Manifest object
+ */
+async function generateManifest() {
+  const aiosCoreDir = path.join(__dirname, '..', '.aios-core');
+  const packageJsonPath = path.join(__dirname, '..', 'package.json');
+
+  if (!fs.existsSync(aiosCoreDir)) {
+    throw new Error(`.aios-core directory not found at ${aiosCoreDir}`);
+  }
+
+  // Get version from package.json
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const version = packageJson.version;
+
+  console.log(`Generating manifest for aios-core v${version}...`);
+
+  const allFiles = [];
+
+  // Scan folders
+  for (const folder of FOLDERS_TO_COPY) {
+    const folderPath = path.join(aiosCoreDir, folder);
+    if (fs.existsSync(folderPath)) {
+      scanDirectory(folderPath, aiosCoreDir, allFiles);
+    }
+  }
+
+  // Add root files
+  for (const file of ROOT_FILES_TO_COPY) {
+    const filePath = path.join(aiosCoreDir, file);
+    if (fs.existsSync(filePath)) {
+      allFiles.push(filePath);
+    }
+  }
+
+  // Note: install-manifest.yaml itself is not included in the manifest
+  // as it would create a circular dependency during validation
+
+  console.log(`Found ${allFiles.length} files to include in manifest`);
+
+  // Generate file entries with metadata
+  const fileEntries = [];
+  let processedCount = 0;
+
+  for (const fullPath of allFiles) {
+    try {
+      const relativePath = path.relative(aiosCoreDir, fullPath).replace(/\\/g, '/');
+      const stats = fs.statSync(fullPath);
+      const hash = hashFile(fullPath);
+      const fileType = getFileType(relativePath);
+
+      fileEntries.push({
+        path: relativePath,
+        hash: `sha256:${hash}`,
+        type: fileType,
+        size: stats.size,
+      });
+
+      processedCount++;
+      if (processedCount % 50 === 0) {
+        console.log(`  Processed ${processedCount}/${allFiles.length} files...`);
+      }
+    } catch (error) {
+      console.warn(`  Warning: Could not process ${fullPath}: ${error.message}`);
+    }
+  }
+
+  // Sort files by path for consistent output
+  fileEntries.sort((a, b) => a.path.localeCompare(b.path));
+
+  // Build manifest object
+  const manifest = {
+    version: version,
+    generated_at: new Date().toISOString(),
+    generator: 'scripts/generate-install-manifest.js',
+    file_count: fileEntries.length,
+    files: fileEntries,
+  };
+
+  return manifest;
+}
+
+/**
+ * Write manifest to file
+ * @param {Object} manifest - Manifest object
+ */
+async function writeManifest(manifest) {
+  const manifestPath = path.join(__dirname, '..', '.aios-core', 'install-manifest.yaml');
+
+  // Generate YAML with custom options for readability
+  const yamlContent = yaml.dump(manifest, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false,
+    quotingType: '"',
+  });
+
+  // Add header comment
+  const header = `# AIOS-Core Install Manifest
+# Auto-generated by scripts/generate-install-manifest.js
+# DO NOT EDIT MANUALLY - regenerate with: npm run generate:manifest
+#
+# This manifest is used for brownfield upgrades to track:
+# - Which files are part of the framework
+# - SHA256 hashes for change detection
+# - File types for categorization
+#
+`;
+
+  fs.writeFileSync(manifestPath, header + yamlContent, 'utf8');
+
+  console.log(`\nManifest written to: ${manifestPath}`);
+  console.log(`  Version: ${manifest.version}`);
+  console.log(`  Files: ${manifest.file_count}`);
+  console.log(`  Generated: ${manifest.generated_at}`);
+
+  // Also compute and display manifest hash for integrity verification
+  const manifestHash = hashString(yamlContent);
+  console.log(`  Manifest hash: sha256:${manifestHash.substring(0, 16)}...`);
+
+  return manifestPath;
+}
+
+/**
+ * Main execution
+ */
+async function main() {
+  try {
+    console.log('='.repeat(60));
+    console.log('AIOS-Core Install Manifest Generator');
+    console.log('='.repeat(60));
+    console.log('');
+
+    const manifest = await generateManifest();
+    await writeManifest(manifest);
+
+    console.log('\n✅ Manifest generated successfully!');
+    process.exit(0);
+  } catch (error) {
+    console.error('\n❌ Error generating manifest:', error.message);
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  generateManifest,
+  writeManifest,
+  getFileType,
+  scanDirectory,
+  FOLDERS_TO_COPY,
+  ROOT_FILES_TO_COPY,
+};