aios-core 3.0.0 → 3.2.0

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,
+};

package/scripts/validate-manifest.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+/**
+ * Validate Install Manifest
+ * Ensures install-manifest.yaml is up-to-date with actual files
+ *
+ * @script scripts/validate-manifest.js
+ * @story 6.18 - Dynamic Manifest & Brownfield Upgrade System
+ *
+ * Usage:
+ *   node scripts/validate-manifest.js
+ *   npm run validate:manifest
+ *
+ * Exit codes:
+ *   0 - Manifest is valid and up-to-date
+ *   1 - Manifest is outdated or has issues
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+const { hashFile } = require('../src/installer/file-hasher');
+const {
+  scanDirectory,
+  FOLDERS_TO_COPY,
+  ROOT_FILES_TO_COPY,
+  getFileType,
+} = require('./generate-install-manifest');
+
+/**
+ * Validation result object
+ * @typedef {Object} ValidationResult
+ * @property {boolean} valid - Whether manifest is valid
+ * @property {string[]} newFiles - Files in filesystem but not in manifest
+ * @property {string[]} removedFiles - Files in manifest but not in filesystem
+ * @property {string[]} modifiedFiles - Files with different hashes
+ * @property {string[]} errors - Error messages
+ */
+
+/**
+ * Load and parse the install manifest
+ * @returns {Object|null} - Parsed manifest or null if not found
+ */
+function loadManifest() {
+  const manifestPath = path.join(__dirname, '..', '.aios-core', 'install-manifest.yaml');
+
+  if (!fs.existsSync(manifestPath)) {
+    return null;
+  }
+
+  const content = fs.readFileSync(manifestPath, 'utf8');
+  return yaml.load(content);
+}
+
+/**
+ * Get current files from filesystem
+ * @returns {Map<string, Object>} - Map of relativePath -> file metadata
+ */
+function getCurrentFiles() {
+  const aiosCoreDir = path.join(__dirname, '..', '.aios-core');
+  const filesMap = new Map();
+
+  // Scan folders
+  const allFiles = [];
+  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);
+    }
+  }
+
+  // Build map
+  for (const fullPath of allFiles) {
+    const relativePath = path.relative(aiosCoreDir, fullPath).replace(/\\/g, '/');
+    try {
+      const hash = hashFile(fullPath);
+      filesMap.set(relativePath, {
+        path: relativePath,
+        hash: `sha256:${hash}`,
+        type: getFileType(relativePath),
+      });
+    } catch (error) {
+      console.warn(`Warning: Could not hash ${relativePath}: ${error.message}`);
+    }
+  }
+
+  return filesMap;
+}
+
+/**
+ * Validate manifest against current filesystem
+ * @returns {ValidationResult} - Validation results
+ */
+function validateManifest() {
+  const result = {
+    valid: true,
+    newFiles: [],
+    removedFiles: [],
+    modifiedFiles: [],
+    errors: [],
+  };
+
+  // Load manifest
+  const manifest = loadManifest();
+  if (!manifest) {
+    result.valid = false;
+    result.errors.push('install-manifest.yaml not found');
+    return result;
+  }
+
+  if (!manifest.files || !Array.isArray(manifest.files)) {
+    result.valid = false;
+    result.errors.push('Manifest has no files array');
+    return result;
+  }
+
+  // Get current files
+  const currentFiles = getCurrentFiles();
+
+  // Build set of manifest paths
+  const manifestPaths = new Set();
+  const manifestMap = new Map();
+
+  for (const entry of manifest.files) {
+    const normalizedPath = entry.path.replace(/\\/g, '/');
+    manifestPaths.add(normalizedPath);
+    manifestMap.set(normalizedPath, entry);
+  }
+
+  // Check for new files (in filesystem but not in manifest)
+  for (const [filePath, _fileData] of currentFiles) {
+    if (!manifestPaths.has(filePath)) {
+      result.newFiles.push(filePath);
+      result.valid = false;
+    }
+  }
+
+  // Check for removed files and hash mismatches
+  for (const [manifestPath, manifestEntry] of manifestMap) {
+    const currentFile = currentFiles.get(manifestPath);
+
+    if (!currentFile) {
+      // File in manifest but not in filesystem
+      result.removedFiles.push(manifestPath);
+      result.valid = false;
+    } else if (currentFile.hash !== manifestEntry.hash) {
+      // Hash mismatch
+      result.modifiedFiles.push({
+        path: manifestPath,
+        manifestHash: manifestEntry.hash,
+        currentHash: currentFile.hash,
+      });
+      result.valid = false;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Print validation report
+ * @param {ValidationResult} result - Validation results
+ */
+function printReport(result) {
+  console.log('='.repeat(60));
+  console.log('AIOS-Core Manifest Validation Report');
+  console.log('='.repeat(60));
+  console.log('');
+
+  if (result.errors.length > 0) {
+    console.log('❌ ERRORS:');
+    for (const error of result.errors) {
+      console.log(`   - ${error}`);
+    }
+    console.log('');
+  }
+
+  if (result.newFiles.length > 0) {
+    console.log(`📁 NEW FILES (${result.newFiles.length}) - not in manifest:`);
+    for (const file of result.newFiles.slice(0, 20)) {
+      console.log(`   + ${file}`);
+    }
+    if (result.newFiles.length > 20) {
+      console.log(`   ... and ${result.newFiles.length - 20} more`);
+    }
+    console.log('');
+  }
+
+  if (result.removedFiles.length > 0) {
+    console.log(`🗑️  REMOVED FILES (${result.removedFiles.length}) - in manifest but missing:`);
+    for (const file of result.removedFiles.slice(0, 20)) {
+      console.log(`   - ${file}`);
+    }
+    if (result.removedFiles.length > 20) {
+      console.log(`   ... and ${result.removedFiles.length - 20} more`);
+    }
+    console.log('');
+  }
+
+  if (result.modifiedFiles.length > 0) {
+    console.log(`📝 MODIFIED FILES (${result.modifiedFiles.length}) - hash mismatch:`);
+    for (const file of result.modifiedFiles.slice(0, 20)) {
+      console.log(`   ~ ${file.path}`);
+      if (process.env.VERBOSE) {
+        console.log(`     manifest: ${file.manifestHash}`);
+        console.log(`     current:  ${file.currentHash}`);
+      }
+    }
+    if (result.modifiedFiles.length > 20) {
+      console.log(`   ... and ${result.modifiedFiles.length - 20} more`);
+    }
+    console.log('');
+  }
+
+  // Summary
+  console.log('-'.repeat(60));
+  if (result.valid) {
+    console.log('✅ Manifest is VALID and up-to-date');
+  } else {
+    console.log('❌ Manifest is OUTDATED');
+    console.log('');
+    console.log('To fix, run: npm run generate:manifest');
+  }
+  console.log('-'.repeat(60));
+}
+
+/**
+ * Main execution
+ */
+async function main() {
+  try {
+    const result = validateManifest();
+    printReport(result);
+
+    if (!result.valid) {
+      process.exit(1);
+    }
+    process.exit(0);
+  } catch (error) {
+    console.error('\n❌ Error validating 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 = {
+  validateManifest,
+  loadManifest,
+  getCurrentFiles,
+  printReport,
+};

package/squads/.designs/duplicate-test-design.yaml

@@ -0,0 +1,23 @@
+# Squad Design Blueprint
+# Generated by *design-squad
+# Source: Interactive input
+# Created: 2025-12-18T23:01:55.322Z
+
+squad:
+  name: duplicate-test
+  domain: test
+analysis:
+  entities: []
+  workflows: []
+  integrations: []
+  stakeholders: []
+recommendations:
+  agents: []
+  tasks: []
+  template: basic
+  config_mode: extend
+metadata:
+  created_at: '2025-12-18T23:01:55.322Z'
+  source_docs: []
+  user_adjustments: 0
+  overall_confidence: 0.5

package/squads/.designs/force-test-design.yaml

@@ -0,0 +1,23 @@
+# Squad Design Blueprint
+# Generated by *design-squad
+# Source: Interactive input
+# Created: 2025-12-18T23:01:55.323Z
+
+squad:
+  name: force-test
+  domain: test-v1
+analysis:
+  entities: []
+  workflows: []
+  integrations: []
+  stakeholders: []
+recommendations:
+  agents: []
+  tasks: []
+  template: basic
+  config_mode: extend
+metadata:
+  created_at: '2025-12-18T23:01:55.323Z'
+  source_docs: []
+  user_adjustments: 0
+  overall_confidence: 0.5

package/squads/.designs/nested-test-design.yaml

@@ -0,0 +1,23 @@
+# Squad Design Blueprint
+# Generated by *design-squad
+# Source: Interactive input
+# Created: 2025-12-18T23:01:55.321Z
+
+squad:
+  name: nested-test
+  domain: test
+analysis:
+  entities: []
+  workflows: []
+  integrations: []
+  stakeholders: []
+recommendations:
+  agents: []
+  tasks: []
+  template: basic
+  config_mode: extend
+metadata:
+  created_at: '2025-12-18T23:01:55.321Z'
+  source_docs: []
+  user_adjustments: 0
+  overall_confidence: 0.5

package/squads/.designs/test-squad-design.yaml

@@ -0,0 +1,23 @@
+# Squad Design Blueprint
+# Generated by *design-squad
+# Source: Interactive input
+# Created: 2025-12-18T23:01:55.317Z
+
+squad:
+  name: test-squad
+  domain: test-domain
+analysis:
+  entities: []
+  workflows: []
+  integrations: []
+  stakeholders: []
+recommendations:
+  agents: []
+  tasks: []
+  template: basic
+  config_mode: extend
+metadata:
+  created_at: '2025-12-18T23:01:55.317Z'
+  source_docs: []
+  user_adjustments: 0
+  overall_confidence: 0.5