aios-core 4.0.4 → 4.2.0

package/packages/installer/src/config/ide-configs.js

@@ -25,8 +25,9 @@ const path = require('path');
 /**
  * IDE Configuration Metadata
  *
- * Synkra AIOS v2.1 supports 5 main IDEs:
+ * Synkra AIOS v4 supports 6 main IDEs:
  * - Claude Code (Anthropic's official CLI) - Recommended
+ * - Codex CLI (OpenAI coding CLI)
  * - Cursor (AI-first code editor)
  * - Windsurf (AI-powered development)
  * - GitHub Copilot (GitHub's AI pair programmer)
@@ -43,6 +44,16 @@ const IDE_CONFIGS = {
     recommended: true,
     agentFolder: path.join('.claude', 'commands', 'AIOS', 'agents'),
   },
+  codex: {
+    name: 'Codex CLI',
+    description: '',
+    configFile: 'AGENTS.md',
+    template: 'ide-rules/codex-rules.md',
+    requiresDirectory: false,
+    format: 'text',
+    recommended: true,
+    agentFolder: path.join('.codex', 'agents'),
+  },
   cursor: {
     name: 'Cursor',
     description: '',

package/packages/installer/src/config/templates/core-config-template.js

@@ -118,7 +118,7 @@ function generateCoreConfig(options = {}) {
       enabled: true,
       heavySections: [
         'pvMindContext',
-        'expansionPacks',
+        'squads',
         'registry',
       ],
     },
@@ -146,7 +146,7 @@ function generateCoreConfig(options = {}) {
     scriptsLocation: '.aios-core/scripts',
     dataLocation: '.aios-core/data',
     elicitationLocation: '.aios-core/elicitation',
-    expansionPacksLocation: 'expansion-packs',
+    squadsLocation: 'squads',
     mindsLocation: 'outputs/minds',
 
     // Project Status Configuration

package/packages/installer/src/installer/aios-core-installer.js

@@ -24,11 +24,11 @@ function getAiosCoreSourcePath() {
 
 /**
  * Folders to copy from .aios-core
- * Includes both v2.1 modular structure and v2.0 legacy flat structure for compatibility
+ * Includes both v4 modular structure and v2.0 legacy flat structure for compatibility
  * @constant {string[]}
  */
 const FOLDERS_TO_COPY = [
-  // v2.1 Modular Structure (Story 2.15)
+  // v4.0.4 Modular Structure (Story 2.15)
   'core',           // Framework utilities, config, registry, migration
   'development',    // Agents, tasks, workflows, scripts, personas
   'product',        // Templates, checklists, cli, api

package/packages/installer/src/installer/file-hasher.js

@@ -87,6 +87,100 @@ function hashFile(filePath) {
   return crypto.createHash('sha256').update(content).digest('hex');
 }
 
+/**
+ * Async version of hashFile for parallel processing.
+ * INS-2 Performance: Enables parallel hashing with Promise.all
+ *
+ * @param {string} filePath - Absolute path to the file
+ * @returns {Promise<string>} - SHA256 hash as hex string
+ * @throws {Error} - If file cannot be read
+ */
+async function hashFileAsync(filePath) {
+  const exists = await fs.pathExists(filePath);
+  if (!exists) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  const stats = await fs.stat(filePath);
+  if (stats.isDirectory()) {
+    throw new Error(`Cannot hash directory: ${filePath}`);
+  }
+
+  let content;
+
+  if (isBinaryFile(filePath)) {
+    // Binary files: hash raw bytes
+    content = await fs.readFile(filePath);
+  } else {
+    // Text files: normalize line endings and remove BOM
+    const rawContent = await fs.readFile(filePath, 'utf8');
+    const withoutBOM = removeBOM(rawContent);
+    const normalized = normalizeLineEndings(withoutBOM);
+    content = Buffer.from(normalized, 'utf8');
+  }
+
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+/**
+ * Async version of hashesMatch using hashFileAsync.
+ *
+ * @param {string} filePath1 - First file path
+ * @param {string} filePath2 - Second file path
+ * @returns {Promise<boolean>} - True if file hashes match
+ */
+async function hashFilesMatchAsync(filePath1, filePath2) {
+  try {
+    const [hash1, hash2] = await Promise.all([
+      hashFileAsync(filePath1),
+      hashFileAsync(filePath2),
+    ]);
+    return hashesMatch(hash1, hash2);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Hash multiple files in parallel with batch processing
+ * INS-2 Performance: Process files in batches to prevent memory exhaustion
+ *
+ * @param {string[]} filePaths - Array of absolute file paths
+ * @param {number} batchSize - Number of files to hash concurrently (default: 50)
+ * @param {Function} onProgress - Optional progress callback (current, total)
+ * @returns {Promise<Map<string, string>>} - Map of filePath -> hash
+ */
+async function hashFilesParallel(filePaths, batchSize = 50, onProgress = null) {
+  const results = new Map();
+  const total = filePaths.length;
+
+  for (let i = 0; i < total; i += batchSize) {
+    const batch = filePaths.slice(i, i + batchSize);
+    const batchResults = await Promise.all(
+      batch.map(async (filePath) => {
+        try {
+          const hash = await hashFileAsync(filePath);
+          return { filePath, hash, error: null };
+        } catch (error) {
+          return { filePath, hash: null, error: error.message };
+        }
+      }),
+    );
+
+    for (const result of batchResults) {
+      if (result.hash) {
+        results.set(result.filePath, result.hash);
+      }
+    }
+
+    if (onProgress) {
+      onProgress(Math.min(i + batchSize, total), total);
+    }
+  }
+
+  return results;
+}
+
 /**
  * Compute SHA256 hash of a string (for manifest integrity)
  * @param {string} content - String content to hash
@@ -127,8 +221,11 @@ function getFileMetadata(filePath, basePath) {
 
 module.exports = {
   hashFile,
+  hashFileAsync,
+  hashFilesParallel,
   hashString,
   hashesMatch,
+  hashFilesMatchAsync,
   getFileMetadata,
   isBinaryFile,
   normalizeLineEndings,

package/packages/installer/src/installer/post-install-validator.js

@@ -359,6 +359,27 @@ class PostInstallValidator {
       extraFiles: 0,
       skippedFiles: 0,
     };
+
+    // INS-2 Performance: Cache realpath of target directory (computed once, used for all files)
+    // This eliminates redundant fs.realpathSync() calls - 50% reduction in syscalls
+    this._realTargetDirCache = null;
+  }
+
+  /**
+   * Get the real path of the target directory (cached)
+   * INS-2 Performance Optimization: Reduces syscalls from 2 to 1 per file validation
+   * @returns {string|null} - Real path or null if resolution fails
+   */
+  _getRealTargetDir() {
+    if (this._realTargetDirCache === null) {
+      try {
+        this._realTargetDirCache = fs.realpathSync(this.aiosCoreTarget);
+      } catch {
+        // Will be handled by caller
+        return null;
+      }
+    }
+    return this._realTargetDirCache;
   }
 
   /**
@@ -681,9 +702,28 @@ class PostInstallValidator {
     // both the file path AND the target directory to their real paths, then
     // comparing containment. The key security check is: does the real path of the
     // file stay within the real path of the target directory?
+    //
+    // INS-2 Performance: realTargetDir is now cached via _getRealTargetDir()
+    // This reduces syscalls from 2 to 1 per file (50% reduction)
     try {
       const realPath = fs.realpathSync(absolutePath);
-      const realTargetDir = fs.realpathSync(this.aiosCoreTarget);
+      const realTargetDir = this._getRealTargetDir();
+
+      // Handle case where target dir resolution failed
+      if (realTargetDir === null) {
+        this.log('SECURITY: Cannot resolve realpath for target directory');
+        result.issue = {
+          type: IssueType.PERMISSION_ERROR,
+          severity: Severity.CRITICAL,
+          message: 'Cannot resolve real path for target directory',
+          details: 'Target directory realpath resolution failed',
+          category,
+          remediation: 'Check directory permissions',
+          relativePath,
+        };
+        this.stats.skippedFiles++;
+        return result;
+      }
 
       // SECURITY: Verify realpath is still contained within REAL target directory
       // This handles system symlinks like /tmp -> /private/tmp correctly

package/packages/installer/src/pro/pro-scaffolder.js

@@ -0,0 +1,335 @@
+/**
+ * Pro Content Scaffolder
+ *
+ * Copies premium content (squads, configs, feature registry) from
+ * node_modules/@aios-fullstack/pro/ into the user's project after
+ * license activation.
+ *
+ * @module packages/installer/src/pro/pro-scaffolder
+ * @story INS-3.1 — Implement Pro Content Scaffolder
+ */
+
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+const { hashFileAsync, hashFilesMatchAsync } = require('../installer/file-hasher');
+
+/**
+ * Items to scaffold from pro package into user project.
+ * Each entry defines source (relative to proSourceDir) and dest (relative to targetDir).
+ */
+const SCAFFOLD_ITEMS = [
+  {
+    type: 'directory',
+    source: 'squads',
+    dest: 'squads',
+    description: 'Pro squads',
+    required: true,
+  },
+  {
+    type: 'file',
+    source: 'pro-config.yaml',
+    dest: path.join('.aios-core', 'pro-config.yaml'),
+    description: 'Pro configuration',
+    required: true,
+  },
+  {
+    type: 'file',
+    source: 'feature-registry.yaml',
+    dest: path.join('.aios-core', 'feature-registry.yaml'),
+    description: 'Feature registry',
+    required: false,
+  },
+];
+
+/**
+ * Scaffold pro content into user project.
+ *
+ * @param {string} targetDir - Project root directory
+ * @param {string} proSourceDir - Path to pro package content (node_modules/@aios-fullstack/pro)
+ * @param {Object} [options={}] - Scaffold options
+ * @param {Function} [options.onProgress] - Progress callback ({item, status, message})
+ * @param {boolean} [options.force=false] - Force overwrite even if content exists
+ * @returns {Promise<Object>} Scaffold result with copiedFiles, warnings, manifest
+ */
+async function scaffoldProContent(targetDir, proSourceDir, options = {}) {
+  const { onProgress = null, force = false } = options;
+
+  const result = {
+    success: false,
+    copiedFiles: [],
+    skippedFiles: [],
+    warnings: [],
+    errors: [],
+    manifest: null,
+    versionInfo: null,
+  };
+
+  // Track files for rollback on partial failure
+  const rollbackFiles = [];
+
+  // Validate pro source exists
+  if (!await fs.pathExists(proSourceDir)) {
+    result.errors.push(
+      `Pro package not found at ${proSourceDir}. Run "npm install @aios-fullstack/pro" first.`
+    );
+    return result;
+  }
+
+  try {
+    for (const item of SCAFFOLD_ITEMS) {
+      const sourcePath = path.join(proSourceDir, item.source);
+      const destPath = path.join(targetDir, item.dest);
+
+      // Check source exists
+      if (!await fs.pathExists(sourcePath)) {
+        if (item.required) {
+          throw new Error(`Required pro content not found: ${item.source}`);
+        }
+        const warning = `${item.description} (${item.source}) not found in pro package — skipping`;
+        result.warnings.push(warning);
+        if (onProgress) {
+          onProgress({ item: item.source, status: 'warning', message: warning });
+        }
+        continue;
+      }
+
+      if (item.type === 'directory') {
+        const copied = await scaffoldDirectory(sourcePath, destPath, { force, rollbackFiles, baseDir: targetDir });
+        result.copiedFiles.push(...copied.copiedFiles);
+        result.skippedFiles.push(...copied.skippedFiles);
+      } else {
+        const copied = await scaffoldFile(sourcePath, destPath, { force, rollbackFiles, baseDir: targetDir });
+        if (copied.skipped) {
+          result.skippedFiles.push(copied.relativePath);
+        } else {
+          result.copiedFiles.push(copied.relativePath);
+        }
+      }
+
+      if (onProgress) {
+        onProgress({ item: item.source, status: 'done', message: `${item.description} scaffolded` });
+      }
+    }
+
+    // Generate pro-version.json (AC4)
+    const versionInfo = await generateProVersionJson(targetDir, proSourceDir, result.copiedFiles);
+    result.versionInfo = versionInfo;
+    result.copiedFiles.push('pro-version.json');
+    rollbackFiles.push(path.join(targetDir, 'pro-version.json'));
+
+    // Generate pro-installed-manifest.yaml (AC8)
+    const manifest = await generateInstalledManifest(targetDir, result.copiedFiles);
+    result.manifest = manifest;
+    result.copiedFiles.push('pro-installed-manifest.yaml');
+    rollbackFiles.push(path.join(targetDir, 'pro-installed-manifest.yaml'));
+
+    result.success = true;
+
+  } catch (error) {
+    result.errors.push(error.message);
+
+    // Rollback partially copied files (AC6)
+    const rollbackResult = await rollbackScaffold(rollbackFiles);
+    if (rollbackResult.errors.length > 0) {
+      result.errors.push(`Rollback errors: ${rollbackResult.errors.join(', ')}`);
+    }
+    result.warnings.push(
+      `Scaffolding failed: ${error.message}. ${rollbackResult.removed} files cleaned up.`
+    );
+  }
+
+  return result;
+}
+
+/**
+ * Scaffold a directory recursively with idempotency checks.
+ *
+ * @param {string} sourceDir - Source directory
+ * @param {string} destDir - Destination directory
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Result with copiedFiles and skippedFiles
+ */
+async function scaffoldDirectory(sourceDir, destDir, options = {}) {
+  const { force = false, rollbackFiles = [], baseDir } = options;
+  const copiedFiles = [];
+  const skippedFiles = [];
+
+  await fs.ensureDir(destDir);
+
+  const items = await fs.readdir(sourceDir, { withFileTypes: true });
+
+  for (const item of items) {
+    const sourcePath = path.join(sourceDir, item.name);
+    const destPath = path.join(destDir, item.name);
+
+    if (item.isDirectory()) {
+      const sub = await scaffoldDirectory(sourcePath, destPath, options);
+      copiedFiles.push(...sub.copiedFiles);
+      skippedFiles.push(...sub.skippedFiles);
+    } else {
+      const result = await scaffoldFile(sourcePath, destPath, { force, rollbackFiles, baseDir });
+      if (result.skipped) {
+        skippedFiles.push(result.relativePath);
+      } else {
+        copiedFiles.push(result.relativePath);
+      }
+    }
+  }
+
+  return { copiedFiles, skippedFiles };
+}
+
+/**
+ * Scaffold a single file with idempotency (AC5).
+ * If dest exists and has identical hash, skip. If user modified, skip (preserve).
+ *
+ * @param {string} sourcePath - Source file path
+ * @param {string} destPath - Destination file path
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Result with relativePath and skipped flag
+ */
+async function scaffoldFile(sourcePath, destPath, options = {}) {
+  const { force = false, rollbackFiles = [], baseDir } = options;
+  const base = baseDir || path.resolve(destPath, '..', '..');
+  const relativePath = path.relative(base, destPath).replace(/\\/g, '/');
+
+  // Idempotency check (AC5) — async to avoid blocking event loop
+  if (!force && await fs.pathExists(destPath)) {
+    try {
+      if (await hashFilesMatchAsync(sourcePath, destPath)) {
+        // Identical — skip
+        return { relativePath, skipped: true };
+      }
+    } catch {
+      // Hash comparison failed — overwrite to be safe
+    }
+  }
+
+  await fs.ensureDir(path.dirname(destPath));
+  await fs.copy(sourcePath, destPath);
+  rollbackFiles.push(destPath);
+
+  return { relativePath, skipped: false };
+}
+
+/**
+ * Generate pro-version.json with SHA256 hashes for version tracking (AC4).
+ *
+ * @param {string} targetDir - Project root
+ * @param {string} proSourceDir - Pro package directory
+ * @param {string[]} copiedFiles - List of copied file relative paths
+ * @returns {Promise<Object>} Version info object
+ */
+async function generateProVersionJson(targetDir, proSourceDir, copiedFiles) {
+  // Read pro package version
+  let proVersion = 'unknown';
+  const proPkgPath = path.join(proSourceDir, 'package.json');
+  if (await fs.pathExists(proPkgPath)) {
+    try {
+      const proPkg = await fs.readJson(proPkgPath);
+      proVersion = proPkg.version || 'unknown';
+    } catch {
+      // Keep 'unknown'
+    }
+  }
+
+  // Generate hashes for all copied files
+  const fileHashes = {};
+  for (const relativePath of copiedFiles) {
+    const absolutePath = path.join(targetDir, relativePath);
+    try {
+      if (await fs.pathExists(absolutePath)) {
+        const stats = await fs.stat(absolutePath);
+        if (stats.isFile()) {
+          fileHashes[relativePath] = `sha256:${await hashFileAsync(absolutePath)}`;
+        }
+      }
+    } catch {
+      // Skip unhashable files
+    }
+  }
+
+  const versionInfo = {
+    proVersion,
+    installedAt: new Date().toISOString(),
+    fileCount: copiedFiles.length,
+    fileHashes,
+  };
+
+  const versionPath = path.join(targetDir, 'pro-version.json');
+  await fs.writeJson(versionPath, versionInfo, { spaces: 2 });
+
+  return versionInfo;
+}
+
+/**
+ * Generate pro-installed-manifest.yaml listing all scaffolded files (AC8).
+ *
+ * @param {string} targetDir - Project root
+ * @param {string[]} copiedFiles - List of copied file relative paths
+ * @returns {Promise<Object>} Manifest object
+ */
+async function generateInstalledManifest(targetDir, copiedFiles) {
+  const files = [];
+  for (const relativePath of copiedFiles) {
+    const absolutePath = path.join(targetDir, relativePath);
+    let timestamp = new Date().toISOString();
+    try {
+      if (await fs.pathExists(absolutePath)) {
+        const stats = await fs.stat(absolutePath);
+        timestamp = stats.mtime.toISOString();
+      }
+    } catch {
+      // Use current time
+    }
+    files.push({ path: relativePath, timestamp });
+  }
+
+  const manifest = {
+    generatedAt: new Date().toISOString(),
+    totalFiles: files.length,
+    files,
+  };
+
+  const manifestPath = path.join(targetDir, 'pro-installed-manifest.yaml');
+  await fs.writeFile(manifestPath, yaml.dump(manifest), 'utf8');
+
+  return manifest;
+}
+
+/**
+ * Rollback partially scaffolded files on error (AC6).
+ *
+ * @param {string[]} rollbackFiles - Absolute paths to remove
+ * @returns {Promise<Object>} Rollback result with removed count and errors
+ */
+async function rollbackScaffold(rollbackFiles) {
+  let removed = 0;
+  const errors = [];
+
+  for (const filePath of rollbackFiles) {
+    try {
+      if (await fs.pathExists(filePath)) {
+        await fs.remove(filePath);
+        removed++;
+      }
+    } catch (error) {
+      errors.push(`Failed to remove ${filePath}: ${error.message}`);
+    }
+  }
+
+  return { removed, errors };
+}
+
+module.exports = {
+  scaffoldProContent,
+  scaffoldDirectory,
+  scaffoldFile,
+  generateProVersionJson,
+  generateInstalledManifest,
+  rollbackScaffold,
+  SCAFFOLD_ITEMS,
+};

package/packages/installer/src/utils/aios-colors.js

@@ -1,5 +1,5 @@
 /**
- * AIOS Color Palette v2.1
+ * AIOS Color Palette v4.0.4
  * 
  * Brand-inspired color system for CLI tools and terminal output.
  * Colors derived from AIOS logo gradient (magenta → orange → purple → blue)
@@ -189,7 +189,7 @@ const lists = {
  */
 const examples = {
   welcome: () => {
-    console.log(headings.h1('🎉 Welcome to AIOS v2.1 Installer!'));
+    console.log(headings.h1('🎉 Welcome to AIOS v4 Installer!'));
     console.log(colors.info('Let\'s configure your project in just a few steps...\n'));
   },
   

package/packages/installer/src/wizard/feedback.js

@@ -1,7 +1,7 @@
 /**
  * Visual Feedback Helpers
  *
- * Spinners, progress bars, and status indicators using AIOS Color System v2.1
+ * Spinners, progress bars, and status indicators using AIOS Color System v4.0.4
  *
  * @module wizard/feedback
  */

package/packages/installer/src/wizard/ide-config-generator.js

@@ -206,14 +206,14 @@ function generateTemplateVariables(wizardState) {
 
 /**
  * Copy agent files from .aios-core/development/agents to IDE-specific agent folder
- * v2.1 modular structure: agents are now in development/ module
+ * v4 modular structure: agents are now in development/ module
  * @param {string} projectRoot - Project root directory
  * @param {string} agentFolder - Target folder for agent files (IDE-specific)
  * @param {Object} ideConfig - IDE configuration object (optional, for special handling)
  * @returns {Promise<string[]>} List of copied files
  */
 async function copyAgentFiles(projectRoot, agentFolder, ideConfig = null) {
-  // v2.1: Agents are in development/agents/ (not root agents/)
+  // v4: Agents are in development/agents/ (not root agents/)
   const sourceDir = path.join(__dirname, '..', '..', '..', '..', '.aios-core', 'development', 'agents');
   const targetDir = path.join(projectRoot, agentFolder);
   const copiedFiles = [];