aios-core 2.1.0

package/.aios-core/core/migration/module-mapping.yaml

@@ -0,0 +1,89 @@
+# AIOS Module Mapping v2.0 → v2.1
+# Story 2.14 - Migration Script
+
+version: "1.0.0"
+
+# Mapping of v2.0 directories to v2.1 modules
+mapping:
+  core:
+    source: ".aios-core/"
+    target: ".aios-core/core/"
+    files:
+      - registry/**
+      - quality-gates/**
+      - manifest/**
+      - utils/**
+      - elicitation/**
+      - session/**
+      - config/**
+      - mcp/**
+      - data/**
+      - docs/**
+    root_files: true  # Include root-level files
+
+  development:
+    source: ".aios-core/"
+    target: ".aios-core/development/"
+    files:
+      - agents/**
+      - tasks/**
+      - templates/**
+      - checklists/**
+      - scripts/**
+      - personas/**
+
+  product:
+    source: ".aios-core/"
+    target: ".aios-core/product/"
+    files:
+      - cli/**
+      - api/**
+
+  infrastructure:
+    source: ".aios-core/"
+    target: ".aios-core/infrastructure/"
+    files:
+      - hooks/**
+      - telemetry/**
+      - integrations/**
+
+# Import path transformations
+import_transforms:
+  patterns:
+    # Old pattern → New pattern
+    - from: "../../registry/"
+      to: "../../core/registry/"
+    - from: "../../agents/"
+      to: "../../development/agents/"
+    - from: "../../tasks/"
+      to: "../../development/tasks/"
+    - from: "../../cli/"
+      to: "../../product/cli/"
+    - from: "../utils/"
+      to: "../core/utils/"
+
+  file_extensions:
+    - .js
+    - .ts
+    - .mjs
+    - .cjs
+    - .jsx
+    - .tsx
+
+# Files to skip during migration
+exclusions:
+  files:
+    - "*.md"           # Documentation stays in place
+    - "*.yaml"         # Config files handled separately
+    - "*.json"         # JSON configs handled separately
+  directories:
+    - node_modules
+    - .git
+    - dist
+    - build
+
+# Post-migration cleanup
+cleanup:
+  removeEmptyDirs: true
+  removeOldStructure: true
+  preserveGitHistory: true

package/.aios-core/core/quality-gates/base-layer.js

@@ -0,0 +1,134 @@
+/**
+ * Base Layer Class
+ *
+ * Abstract base class for quality gate layers.
+ * Provides common functionality for all layer implementations.
+ *
+ * @module core/quality-gates/base-layer
+ * @version 1.0.0
+ * @story 2.10 - Quality Gate Manager
+ */
+
+/**
+ * Base class for quality gate layers
+ * @abstract
+ */
+class BaseLayer {
+  /**
+   * Create a new layer instance
+   * @param {string} name - Layer name
+   * @param {Object} config - Layer configuration
+   */
+  constructor(name, config = {}) {
+    if (new.target === BaseLayer) {
+      throw new Error('BaseLayer is abstract and cannot be instantiated directly');
+    }
+    this.name = name;
+    this.config = config;
+    this.enabled = config.enabled !== false;
+    this.startTime = null;
+    this.endTime = null;
+    this.results = [];
+  }
+
+  /**
+   * Execute the layer checks
+   * @abstract
+   * @param {Object} context - Execution context
+   * @returns {Promise<Object>} Layer results
+   */
+  async execute(context) {
+    throw new Error('execute() must be implemented by subclass');
+  }
+
+  /**
+   * Start timing for this layer
+   */
+  startTimer() {
+    this.startTime = Date.now();
+  }
+
+  /**
+   * Stop timing and return duration
+   * @returns {number} Duration in milliseconds
+   */
+  stopTimer() {
+    this.endTime = Date.now();
+    return this.getDuration();
+  }
+
+  /**
+   * Get execution duration
+   * @returns {number} Duration in milliseconds
+   */
+  getDuration() {
+    if (!this.startTime) return 0;
+    const end = this.endTime || Date.now();
+    return end - this.startTime;
+  }
+
+  /**
+   * Add a result to the layer results
+   * @param {Object} result - Check result
+   */
+  addResult(result) {
+    this.results.push({
+      ...result,
+      timestamp: Date.now(),
+    });
+  }
+
+  /**
+   * Check if layer passed
+   * @returns {boolean} True if all checks passed
+   */
+  hasPassed() {
+    return this.results.every((r) => r.pass);
+  }
+
+  /**
+   * Get summary of layer results
+   * @returns {Object} Summary object
+   */
+  getSummary() {
+    const passed = this.results.filter((r) => r.pass).length;
+    const failed = this.results.filter((r) => !r.pass).length;
+    const warnings = this.results.filter((r) => r.warnings && r.warnings.length > 0).length;
+
+    return {
+      layer: this.name,
+      enabled: this.enabled,
+      pass: this.hasPassed(),
+      duration: this.getDuration(),
+      checks: {
+        total: this.results.length,
+        passed,
+        failed,
+        warnings,
+      },
+      results: this.results,
+    };
+  }
+
+  /**
+   * Reset layer state for re-execution
+   */
+  reset() {
+    this.startTime = null;
+    this.endTime = null;
+    this.results = [];
+  }
+
+  /**
+   * Format duration for display
+   * @param {number} ms - Duration in milliseconds
+   * @returns {string} Formatted duration
+   */
+  formatDuration(ms) {
+    if (ms < 1000) return `${ms}ms`;
+    if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+    return `${(ms / 60000).toFixed(1)}m`;
+  }
+}
+
+module.exports = { BaseLayer };

package/.aios-core/core/quality-gates/checklist-generator.js

@@ -0,0 +1,329 @@
+/**
+ * Checklist Generator
+ *
+ * Generates strategic review checklists based on:
+ * - Story type and complexity
+ * - Changed files
+ * - Previous layer results
+ *
+ * @module core/quality-gates/checklist-generator
+ * @version 1.0.0
+ * @story 2.10 - Quality Gate Manager
+ */
+
+/**
+ * Strategic review checklist generator
+ */
+class ChecklistGenerator {
+  /**
+   * Create a checklist generator
+   * @param {Object} config - Generator configuration
+   */
+  constructor(config = {}) {
+    this.config = config;
+    this.template = config.template || 'strategic-review-checklist';
+    this.minItems = config.minItems || 5;
+  }
+
+  /**
+   * Generate a review checklist
+   * @param {Object} context - Generation context
+   * @param {string} context.storyId - Story identifier
+   * @param {Array} context.changedFiles - List of changed files
+   * @param {Array} context.layers - Previous layer results
+   * @returns {Promise<Object>} Generated checklist
+   */
+  async generate(context = {}) {
+    const { storyId, changedFiles = [], layers = [] } = context;
+
+    const items = [];
+
+    // Add base review items
+    items.push(...this.getBaseItems());
+
+    // Add items based on changed files
+    items.push(...this.getFileBasedItems(changedFiles));
+
+    // Add items based on previous layer results
+    items.push(...this.getLayerBasedItems(layers));
+
+    // Add story-specific items
+    if (storyId) {
+      items.push(...this.getStoryBasedItems(storyId));
+    }
+
+    // Ensure minimum items
+    while (items.length < this.minItems) {
+      items.push({
+        id: `additional-${items.length}`,
+        text: 'General code quality and standards compliance',
+        category: 'general',
+        priority: 'low',
+        checked: false,
+      });
+    }
+
+    return {
+      template: this.template,
+      storyId,
+      generatedAt: new Date().toISOString(),
+      items: items.map((item, index) => ({
+        ...item,
+        order: index + 1,
+      })),
+    };
+  }
+
+  /**
+   * Get base checklist items
+   * @returns {Array} Base items
+   */
+  getBaseItems() {
+    return [
+      {
+        id: 'architecture-alignment',
+        text: 'Changes align with documented architecture decisions',
+        category: 'architecture',
+        priority: 'high',
+        checked: false,
+      },
+      {
+        id: 'security-review',
+        text: 'No security vulnerabilities introduced (OWASP Top 10)',
+        category: 'security',
+        priority: 'critical',
+        checked: false,
+      },
+      {
+        id: 'performance-impact',
+        text: 'Performance impact assessed and acceptable',
+        category: 'performance',
+        priority: 'medium',
+        checked: false,
+      },
+      {
+        id: 'documentation-updated',
+        text: 'Relevant documentation updated or created',
+        category: 'documentation',
+        priority: 'medium',
+        checked: false,
+      },
+      {
+        id: 'backward-compatibility',
+        text: 'Backward compatibility maintained (or breaking changes documented)',
+        category: 'compatibility',
+        priority: 'high',
+        checked: false,
+      },
+    ];
+  }
+
+  /**
+   * Get items based on changed files
+   * @param {Array} changedFiles - List of changed files
+   * @returns {Array} File-based items
+   */
+  getFileBasedItems(changedFiles = []) {
+    const items = [];
+    const fileCategories = this.categorizeFiles(changedFiles);
+
+    if (fileCategories.tests.length > 0) {
+      items.push({
+        id: 'test-coverage',
+        text: `Test changes reviewed for coverage (${fileCategories.tests.length} test files)`,
+        category: 'testing',
+        priority: 'high',
+        checked: false,
+      });
+    }
+
+    if (fileCategories.configs.length > 0) {
+      items.push({
+        id: 'config-changes',
+        text: `Configuration changes validated (${fileCategories.configs.length} config files)`,
+        category: 'configuration',
+        priority: 'high',
+        checked: false,
+      });
+    }
+
+    if (fileCategories.agents.length > 0) {
+      items.push({
+        id: 'agent-changes',
+        text: `Agent definition changes reviewed (${fileCategories.agents.length} agent files)`,
+        category: 'agents',
+        priority: 'high',
+        checked: false,
+      });
+    }
+
+    if (fileCategories.api.length > 0) {
+      items.push({
+        id: 'api-changes',
+        text: `API changes reviewed for breaking changes (${fileCategories.api.length} API files)`,
+        category: 'api',
+        priority: 'critical',
+        checked: false,
+      });
+    }
+
+    if (fileCategories.database.length > 0) {
+      items.push({
+        id: 'database-changes',
+        text: `Database migrations reviewed (${fileCategories.database.length} migration files)`,
+        category: 'database',
+        priority: 'critical',
+        checked: false,
+      });
+    }
+
+    return items;
+  }
+
+  /**
+   * Categorize files by type
+   * @param {Array} files - List of file paths
+   * @returns {Object} Categorized files
+   */
+  categorizeFiles(files = []) {
+    return {
+      tests: files.filter((f) => f.includes('test') || f.includes('spec')),
+      configs: files.filter((f) =>
+        f.endsWith('.yaml') || f.endsWith('.yml') || f.endsWith('.json') ||
+        f.includes('config') || f.includes('.env'),
+      ),
+      agents: files.filter((f) =>
+        f.includes('agents/') || f.includes('agent'),
+      ),
+      api: files.filter((f) =>
+        f.includes('/api/') || f.includes('routes') || f.includes('endpoints'),
+      ),
+      database: files.filter((f) =>
+        f.includes('migration') || f.includes('schema') || f.includes('database'),
+      ),
+      docs: files.filter((f) =>
+        f.endsWith('.md') || f.includes('/docs/'),
+      ),
+      source: files.filter((f) =>
+        f.endsWith('.js') || f.endsWith('.ts') || f.endsWith('.jsx') || f.endsWith('.tsx'),
+      ),
+    };
+  }
+
+  /**
+   * Get items based on previous layer results
+   * @param {Array} layers - Previous layer results
+   * @returns {Array} Layer-based items
+   */
+  getLayerBasedItems(layers = []) {
+    const items = [];
+
+    layers.forEach((layer) => {
+      if (layer.checks?.warnings > 0) {
+        items.push({
+          id: `${layer.layer}-warnings`,
+          text: `Review ${layer.checks.warnings} warnings from ${layer.layer}`,
+          category: 'quality',
+          priority: 'medium',
+          checked: false,
+        });
+      }
+
+      // Check for specific issues
+      layer.results?.forEach((result) => {
+        if (result.check === 'coderabbit' && result.issues?.high > 0) {
+          items.push({
+            id: 'coderabbit-high-issues',
+            text: `Address ${result.issues.high} HIGH severity issues from CodeRabbit`,
+            category: 'quality',
+            priority: 'high',
+            checked: false,
+          });
+        }
+      });
+    });
+
+    return items;
+  }
+
+  /**
+   * Get items based on story type
+   * @param {string} storyId - Story identifier
+   * @returns {Array} Story-based items
+   */
+  getStoryBasedItems(storyId) {
+    const items = [];
+
+    // Add story completion check
+    items.push({
+      id: 'story-completion',
+      text: `All acceptance criteria for ${storyId} verified`,
+      category: 'story',
+      priority: 'critical',
+      checked: false,
+    });
+
+    // Infer story type from ID pattern
+    if (storyId.includes('2.')) {
+      // Sprint 2 - Architecture/Infrastructure
+      items.push({
+        id: 'architecture-compliance',
+        text: 'Implementation follows modular architecture guidelines',
+        category: 'architecture',
+        priority: 'high',
+        checked: false,
+      });
+    }
+
+    return items;
+  }
+
+  /**
+   * Format checklist for display
+   * @param {Object} checklist - Generated checklist
+   * @returns {string} Formatted checklist
+   */
+  format(checklist) {
+    const lines = [
+      '# Strategic Review Checklist',
+      `Story: ${checklist.storyId || 'N/A'}`,
+      `Generated: ${checklist.generatedAt}`,
+      '',
+      '## Review Items',
+      '',
+    ];
+
+    const byCategory = {};
+    checklist.items.forEach((item) => {
+      if (!byCategory[item.category]) {
+        byCategory[item.category] = [];
+      }
+      byCategory[item.category].push(item);
+    });
+
+    Object.entries(byCategory).forEach(([category, items]) => {
+      lines.push(`### ${this.formatCategory(category)}`);
+      items.forEach((item) => {
+        const checkbox = item.checked ? '[x]' : '[ ]';
+        const priority = item.priority === 'critical' ? '🔴' :
+          item.priority === 'high' ? '🟠' :
+            item.priority === 'medium' ? '🟡' : '🟢';
+        lines.push(`- ${checkbox} ${priority} ${item.text}`);
+      });
+      lines.push('');
+    });
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Format category name for display
+   * @param {string} category - Category name
+   * @returns {string} Formatted category
+   */
+  formatCategory(category) {
+    return category.charAt(0).toUpperCase() + category.slice(1);
+  }
+}
+
+module.exports = { ChecklistGenerator };