aiox-core 5.0.7 → 5.0.8

package/packages/installer/src/installer/brownfield-upgrader.js

@@ -53,10 +53,38 @@ function loadManifest(basePath, manifestName = 'install-manifest.yaml') {
  * @returns {Object|null} - Installed manifest or null if not found
  */
 function loadInstalledManifest(targetDir) {
-  return loadManifest(
+  const installedManifest = loadManifest(
     path.join(targetDir, '.aiox-core'),
     '.installed-manifest.yaml',
   );
+
+  if (installedManifest) {
+    return installedManifest;
+  }
+
+  const versionJsonPath = path.join(targetDir, '.aiox-core', 'version.json');
+  if (!fs.existsSync(versionJsonPath)) {
+    return null;
+  }
+
+  try {
+    const versionInfo = fs.readJsonSync(versionJsonPath);
+    if (!versionInfo || !versionInfo.version || !versionInfo.fileHashes) {
+      return null;
+    }
+
+    return {
+      installed_version: versionInfo.version,
+      files: Object.entries(versionInfo.fileHashes).map(([filePath, hash]) => ({
+        path: filePath,
+        hash,
+        modified_by_user: false,
+      })),
+    };
+  } catch (error) {
+    console.warn(`Error loading version.json from ${versionJsonPath}:`, error.message);
+    return null;
+  }
 }
 
 /**
@@ -150,13 +178,42 @@ function generateUpgradeReport(sourceManifest, installedManifest, targetDir) {
     const absolutePath = path.join(aioxCoreDir, filePath);
 
     if (!installedEntry) {
-      // New file in source
-      report.newFiles.push({
-        path: filePath,
-        type: sourceEntry.type,
-        hash: sourceEntry.hash,
-        size: sourceEntry.size,
-      });
+      // File is not tracked by the installed manifest.
+      // In older releases some files existed on disk without being recorded
+      // in version metadata. Preserve those local files instead of
+      // overwriting them as "new" framework files.
+      if (fs.existsSync(absolutePath)) {
+        try {
+          const currentHash = `sha256:${hashFile(absolutePath)}`;
+          if (hashesMatch(currentHash, sourceEntry.hash)) {
+            report.unchangedFiles++;
+          } else {
+            report.userModifiedFiles.push({
+              path: filePath,
+              type: sourceEntry.type,
+              sourceHash: sourceEntry.hash,
+              installedHash: null,
+              reason: 'Local file exists but is not tracked by installed manifest',
+            });
+          }
+        } catch {
+          report.userModifiedFiles.push({
+            path: filePath,
+            type: sourceEntry.type,
+            sourceHash: sourceEntry.hash,
+            installedHash: null,
+            reason: 'Local file exists but could not be hashed',
+          });
+        }
+      } else {
+        // New file in source
+        report.newFiles.push({
+          path: filePath,
+          type: sourceEntry.type,
+          hash: sourceEntry.hash,
+          size: sourceEntry.size,
+        });
+      }
     } else if (!hashesMatch(sourceEntry.hash, installedEntry.hash)) {
       // File changed in source
       // Check if user modified the local copy
@@ -287,7 +344,7 @@ async function applyUpgrade(report, sourceDir, targetDir, options = {}) {
             result.mergeWarnings = result.mergeWarnings || [];
             for (const conflict of conflicts) {
               result.mergeWarnings.push(
-                `core-config.yaml: ${conflict.identifier} — ${conflict.reason}`
+                `core-config.yaml: ${conflict.identifier} — ${conflict.reason}`,
               );
             }
           }

package/packages/installer/src/installer/dependency-installer.js

@@ -271,6 +271,7 @@ async function installDependencies(options = {}) {
         success: true,
         offlineMode: true,
         packageManager,
+        projectPath,
       };
     }
 
@@ -290,6 +291,7 @@ async function installDependencies(options = {}) {
       return {
         success: true,
         packageManager,
+        projectPath,
       };
     } else {
       spinner.fail('Installation failed');
@@ -300,6 +302,7 @@ async function installDependencies(options = {}) {
       return {
         success: false,
         packageManager,
+        projectPath,
         error: result.error,
         errorCategory: errorInfo.category,
         errorMessage: errorInfo.message,
@@ -315,6 +318,7 @@ async function installDependencies(options = {}) {
 
     return {
       success: false,
+      projectPath,
       error: error.message,
       errorCategory: errorInfo.category,
       errorMessage: errorInfo.message,

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

@@ -2,7 +2,7 @@
  * Pro Content Scaffolder
  *
  * Copies premium content (squads, configs, feature registry) from
- * node_modules/@aiox-fullstack/pro/ into the user's project after
+ * node_modules/@aiox-squads/pro/ (or a legacy Pro scope) into the user's project after
  * license activation.
  *
  * @module packages/installer/src/pro/pro-scaffolder
@@ -55,7 +55,7 @@ const SCAFFOLD_ITEMS = [
  * Scaffold pro content into user project.
  *
  * @param {string} targetDir - Project root directory
- * @param {string} proSourceDir - Path to pro package content (node_modules/@aiox-fullstack/pro)
+ * @param {string} proSourceDir - Path to pro package content (node_modules/@aiox-squads/pro or legacy scopes)
  * @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
@@ -80,7 +80,7 @@ async function scaffoldProContent(targetDir, proSourceDir, options = {}) {
   // Validate pro source exists
   if (!await fs.pathExists(proSourceDir)) {
     result.errors.push(
-      `Pro package not found at ${proSourceDir}. Run "npm install @aiox-fullstack/pro" first.`
+      `Pro package not found at ${proSourceDir}. Run "npx aiox-pro install" or "aiox pro setup" first.`,
     );
     return result;
   }
@@ -160,7 +160,7 @@ async function scaffoldProContent(targetDir, proSourceDir, options = {}) {
       result.errors.push(`Rollback errors: ${rollbackResult.errors.join(', ')}`);
     }
     result.warnings.push(
-      `Scaffolding failed: ${error.message}. ${rollbackResult.removed} files cleaned up.`
+      `Scaffolding failed: ${error.message}. ${rollbackResult.removed} files cleaned up.`,
     );
   }
 
@@ -425,7 +425,7 @@ async function installSquadCommands(targetDir) {
       for (const agentFile of agentFiles) {
         await fs.copy(
           path.join(agentsDir, agentFile),
-          path.join(destDir, agentFile)
+          path.join(destDir, agentFile),
         );
         files.push(path.relative(targetDir, path.join(destDir, agentFile)).replace(/\\/g, '/'));
       }

package/packages/installer/src/updater/index.js

@@ -22,6 +22,91 @@ const https = require('https');
 const { execSync } = require('child_process');
 const { hashFile, hashesMatch } = require('../installer/file-hasher');
 const { PostInstallValidator, formatReport: formatValidationReport } = require('../installer/post-install-validator');
+const {
+  loadSourceManifest,
+  loadInstalledManifest,
+  generateUpgradeReport,
+  applyUpgrade,
+  updateInstalledManifest,
+} = require('../installer/brownfield-upgrader');
+
+function manifestToInstalledManifest(manifest) {
+  if (!manifest || !Array.isArray(manifest.files)) {
+    return null;
+  }
+
+  return {
+    installed_version: manifest.version || 'unknown',
+    files: manifest.files
+      .filter((entry) => entry && entry.path && entry.hash)
+      .map((entry) => ({
+        path: entry.path,
+        hash: entry.hash,
+        type: entry.type,
+        modified_by_user: false,
+      })),
+  };
+}
+
+function extractManifestFileHashes(manifest) {
+  if (!manifest || !Array.isArray(manifest.files)) {
+    return {};
+  }
+
+  const fileHashes = {};
+  for (const entry of manifest.files) {
+    if (entry && entry.path && entry.hash) {
+      fileHashes[entry.path] = entry.hash;
+    }
+  }
+
+  return fileHashes;
+}
+
+function selectInstalledManifest(projectManifest, packageManifest) {
+  if (!projectManifest) {
+    return packageManifest;
+  }
+
+  if (!packageManifest) {
+    return projectManifest;
+  }
+
+  const projectFiles = Array.isArray(projectManifest.files) ? projectManifest.files : [];
+  const packageFiles = Array.isArray(packageManifest.files) ? packageManifest.files : [];
+
+  if (packageFiles.length === 0) {
+    return projectManifest;
+  }
+
+  if (projectFiles.length === 0) {
+    return packageManifest;
+  }
+
+  const mergedFiles = new Map();
+
+  for (const entry of packageFiles) {
+    if (entry && entry.path) {
+      mergedFiles.set(entry.path, entry);
+    }
+  }
+
+  for (const entry of projectFiles) {
+    if (entry && entry.path && !mergedFiles.has(entry.path)) {
+      mergedFiles.set(entry.path, entry);
+    }
+  }
+
+  return {
+    ...projectManifest,
+    installed_version:
+      packageManifest.installed_version ||
+      packageManifest.version ||
+      projectManifest.installed_version ||
+      projectManifest.version,
+    files: Array.from(mergedFiles.values()),
+  };
+}
 
 /**
  * Update status types
@@ -78,6 +163,8 @@ class AIOXUpdater {
     this.versionInfo = null;
     this.changelog = null;
     this.backupDir = null;
+    this.lastSourcePackageRoot = null;
+    this.lastSourceManifest = null;
   }
 
   /**
@@ -467,15 +554,21 @@ class AIOXUpdater {
       }
 
       result.filesUpdated = updateApplied.filesUpdated;
-      result.filesPreserved = customizations.customized.length;
+      result.filesPreserved = updateApplied.filesSkipped?.length || customizations.customized.length;
+      this.lastSourcePackageRoot = updateApplied.sourcePackageRoot || this.lastSourcePackageRoot;
+      this.lastSourceManifest = updateApplied.sourceManifest || this.lastSourceManifest;
 
       // Update version.json
       onProgress('finalizing', 'Updating version info...');
-      await this.updateVersionInfo(checkResult.latest);
+      await this.updateVersionInfo(checkResult.latest, {
+        fileHashes: extractManifestFileHashes(this.lastSourceManifest),
+      });
 
       // Validate installation after update
       onProgress('validating', 'Validating installation...');
-      const validationResult = await this.validateAfterUpdate();
+      const validationResult = await this.validateAfterUpdate({
+        sourceDir: this.lastSourcePackageRoot,
+      });
       result.validationPassed = validationResult.success;
       result.integrityScore = validationResult.integrityScore;
 
@@ -525,6 +618,7 @@ class AIOXUpdater {
     const filesToBackup = [
       'version.json',
       'install-manifest.yaml',
+      'install-manifest.yaml.minisig',
     ];
 
     for (const file of filesToBackup) {
@@ -586,6 +680,9 @@ class AIOXUpdater {
     };
 
     try {
+      const previousPackageRoot = path.join(this.projectRoot, 'node_modules', 'aiox-core');
+      const previousSourceManifest = loadSourceManifest(path.join(previousPackageRoot, '.aiox-core'));
+
       // Use npm to update the package
       const cmd = `npm install aiox-core@${targetVersion} --save-exact`;
       this.log(`Running: ${cmd}`);
@@ -596,11 +693,54 @@ class AIOXUpdater {
         timeout: 120000, // 2 minutes
       });
 
-      result.success = true;
-      result.filesUpdated = 1; // At least package updated
+      const sourcePackageRoot = path.join(this.projectRoot, 'node_modules', 'aiox-core');
+      const sourceAioxCore = path.join(sourcePackageRoot, '.aiox-core');
+      const sourceManifest = loadSourceManifest(sourceAioxCore);
+
+      if (!sourceManifest) {
+        result.error = 'Updated package does not contain install-manifest.yaml';
+        return result;
+      }
 
-      // TODO: Copy new files from node_modules to .aiox-core
-      // preserving customizedFiles
+      const installedManifest = selectInstalledManifest(
+        loadInstalledManifest(this.projectRoot),
+        manifestToInstalledManifest(previousSourceManifest),
+      );
+      const report = generateUpgradeReport(sourceManifest, installedManifest, this.projectRoot);
+      const applyResult = await applyUpgrade(report, sourceAioxCore, this.projectRoot, {
+        includeModified: true,
+      });
+
+      if (!applyResult.success) {
+        result.error = applyResult.errors.map((entry) => `${entry.path}: ${entry.error}`).join('; ');
+        return result;
+      }
+
+      await fs.copy(
+        path.join(sourceAioxCore, 'install-manifest.yaml'),
+        path.join(this.aioxCoreDir, 'install-manifest.yaml'),
+        { overwrite: true },
+      );
+
+      const sourceSignaturePath = path.join(sourceAioxCore, 'install-manifest.yaml.minisig');
+      const targetSignaturePath = path.join(this.aioxCoreDir, 'install-manifest.yaml.minisig');
+      if (await fs.pathExists(sourceSignaturePath)) {
+        await fs.copy(
+          sourceSignaturePath,
+          targetSignaturePath,
+          { overwrite: true },
+        );
+      } else if (await fs.pathExists(targetSignaturePath)) {
+        await fs.remove(targetSignaturePath);
+      }
+
+      updateInstalledManifest(this.projectRoot, sourceManifest, `aiox-core@${targetVersion}`);
+
+      result.success = true;
+      result.filesUpdated = applyResult.filesInstalled.length;
+      result.filesSkipped = applyResult.filesSkipped;
+      result.sourceManifest = sourceManifest;
+      result.sourcePackageRoot = sourcePackageRoot;
 
       return result;
     } catch (error) {
@@ -615,7 +755,7 @@ class AIOXUpdater {
    * @param {string} newVersion - New version
    * @returns {Promise<void>}
    */
-  async updateVersionInfo(newVersion) {
+  async updateVersionInfo(newVersion, options = {}) {
     const versionJsonPath = path.join(this.aioxCoreDir, 'version.json');
 
     const versionInfo = {
@@ -623,7 +763,7 @@ class AIOXUpdater {
       installedAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
       mode: this.versionInfo?.mode || 'project-development',
-      fileHashes: {}, // Will be populated by file copy
+      fileHashes: options.fileHashes || {},
     };
 
     await fs.writeJson(versionJsonPath, versionInfo, { spaces: 2 });
@@ -646,7 +786,7 @@ class AIOXUpdater {
     };
 
     try {
-      const validator = new PostInstallValidator(this.projectRoot, null, {
+      const validator = new PostInstallValidator(this.projectRoot, options.sourceDir || null, {
         verifyHashes: true,
         detectExtras: false,
         verbose: options.verbose || this.options.verbose,
@@ -809,4 +949,5 @@ module.exports = {
   FileAction,
   formatCheckResult,
   formatUpdateResult,
+  selectInstalledManifest,
 };

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

@@ -16,6 +16,7 @@ const { spawnSync } = require('child_process');
 const { getIDEConfig } = require('../config/ide-configs');
 const { validateProjectName } = require('./validators');
 const { getMergeStrategy, hasMergeStrategy } = require('../merger/index.js');
+const { syncSkills } = require('../../../../.aiox-core/infrastructure/scripts/codex-skills-sync/index');
 
 /**
  * Render template with variables
@@ -83,7 +84,11 @@ async function backupFile(filePath) {
 async function promptFileExists(filePath, options = {}) {
   const { projectType, forceMerge, noMerge } = options;
   const canMerge = !noMerge && hasMergeStrategy(filePath);
-  const isBrownfield = projectType === 'BROWNFIELD' || projectType === 'EXISTING_AIOX';
+  const normalizedProjectType = String(projectType || '').toLowerCase();
+  const isBrownfield =
+    normalizedProjectType === 'brownfield' ||
+    normalizedProjectType === 'existing_aiox' ||
+    normalizedProjectType === 'existing-aiox';
 
   // If force merge is set and merge is available, return merge directly
   if (forceMerge && canMerge) {
@@ -264,7 +269,7 @@ async function copyAgentFiles(projectRoot, agentFolder, ideConfig = null) {
           const targetPath = path.join(targetDir, filename);
           await fs.writeFile(targetPath, content, 'utf8');
           copiedFiles.push(targetPath);
-        } catch (transformError) {
+        } catch (_transformError) {
           // Fallback: copy raw file with .agent.md extension
           const targetPath = path.join(targetDir, `${agentName}.agent.md`);
           await fs.copy(sourcePath, targetPath);
@@ -538,7 +543,7 @@ async function generateIDEConfigs(selectedIDEs, wizardState, options = {}) {
 
           // BUG-3 fix (INS-1): Copy .claude/hooks/ folder (SYNAPSE engine + precompact)
           spinner.start('Copying Claude Code hooks...');
-          const hookFiles = await copyClaudeHooksFolder(projectRoot);
+          const hookFiles = await copyClaudeHooksFolder(projectRoot, wizardState);
           createdFiles.push(...hookFiles);
           if (hookFiles.length > 0) {
             createdFolders.push(path.join(projectRoot, '.claude', 'hooks'));
@@ -656,9 +661,10 @@ function showSuccessSummary(result) {
  * BUG-3 fix (INS-1): Copy .claude/hooks/ folder during installation
  * Only copies JS hooks that work without external dependencies (Python, etc.)
  * @param {string} projectRoot - Project root directory
+ * @param {Object} [wizardState={}] - Current wizard state
  * @returns {Promise<string[]>} List of copied files
  */
-async function copyClaudeHooksFolder(projectRoot) {
+async function copyClaudeHooksFolder(projectRoot, wizardState = {}) {
   const sourceDir = path.join(__dirname, '..', '..', '..', '..', '.claude', 'hooks');
   const targetDir = path.join(projectRoot, '.claude', 'hooks');
   const copiedFiles = [];
@@ -674,13 +680,17 @@ async function copyClaudeHooksFolder(projectRoot) {
 
   await fs.ensureDir(targetDir);
 
-  // Only copy JS hooks that work standalone (no Python/shell deps)
-  const HOOKS_TO_COPY = [
+  const HOOKS_FREE = [
     'synapse-engine.cjs',
     'code-intel-pretool.cjs',
-    'precompact-session-digest.cjs',
     'README.md',
   ];
+  const HOOKS_PRO_ONLY = [
+    'precompact-session-digest.cjs',
+  ];
+  const HOOKS_TO_COPY = shouldCopyProHooks(wizardState)
+    ? [...HOOKS_FREE, ...HOOKS_PRO_ONLY]
+    : HOOKS_FREE;
 
   const files = await fs.readdir(sourceDir);
 
@@ -702,6 +712,31 @@ async function copyClaudeHooksFolder(projectRoot) {
   return copiedFiles;
 }
 
+/**
+ * Decide whether Pro-only hooks should be copied.
+ * Explicit wizard tier wins; otherwise fall back to runtime Pro detection.
+ * Supports wizardState.proTier as a legacy alias from older Pro setup state.
+ *
+ * @param {Object} [wizardState={}] - Current wizard state
+ * @returns {boolean} true when Pro-only hooks should be installed
+ */
+function shouldCopyProHooks(wizardState = {}) {
+  const tier = String(wizardState.tier || wizardState.proTier || '').toLowerCase();
+  if (tier === 'pro') return true;
+  if (['free', 'community', 'core'].includes(tier)) return false;
+
+  if (wizardState.pro && typeof wizardState.pro.enabled === 'boolean') {
+    return wizardState.pro.enabled;
+  }
+
+  try {
+    const { isProAvailable } = require('../../../../bin/utils/pro-detector');
+    return isProAvailable();
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Hook event mapping: fileName → { event, matcher, timeout }
  * Maps each .cjs hook file to its correct Claude Code event.
@@ -1090,6 +1125,35 @@ async function copySkillFiles(projectRoot, _sourceRoot) {
   return { count, skipped: false };
 }
 
+/**
+ * Generate project-local Codex skills from canonical agent definitions.
+ * This repo uses local-first Codex activation, so installed projects must
+ * include `.codex/skills` without requiring a manual post-install sync.
+ * @param {string} projectRoot - Project root directory
+ * @returns {{count: number, skipped: boolean}} Generation result
+ */
+function generateCodexSkills(projectRoot) {
+  const sourceDir = path.join(projectRoot, '.aiox-core', 'development', 'agents');
+  const localSkillsDir = path.join(projectRoot, '.codex', 'skills');
+
+  if (!fs.existsSync(sourceDir)) {
+    return { count: 0, skipped: true };
+  }
+
+  const result = syncSkills({
+    projectRoot,
+    sourceDir,
+    localSkillsDir,
+    dryRun: false,
+    quiet: true,
+  });
+
+  return {
+    count: result.generated || 0,
+    skipped: false,
+  };
+}
+
 /**
  * Copy extra .claude/commands/ files during installation (Story INS-4.3, Gap #12)
  * Uses an allowlist of distributable top-level directories to prevent leaking
@@ -1174,8 +1238,10 @@ module.exports = {
   promptFileExists,
   generateTemplateVariables,
   copyClaudeHooksFolder,
+  shouldCopyProHooks,
   createClaudeSettingsLocal,
   copySkillFiles,
+  generateCodexSkills,
   copyExtraCommandFiles,
   copyGeminiHooksFolder,
   createGeminiSettings,