aios-core 2.1.0

package/.aios-core/infrastructure/scripts/framework-analyzer.js

@@ -0,0 +1,746 @@
+const fs = require('fs').promises;
+const path = require('path');
+const yaml = require('js-yaml');
+const chalk = require('chalk');
+
+/**
+ * Framework structure analyzer for AIOS-FULLSTACK
+ * Discovers and catalogs all framework components
+ */
+class FrameworkAnalyzer {
+  constructor(options = {}) {
+    this.rootPath = options.rootPath || process.cwd();
+    this.aiosCoreDir = path.join(this.rootPath, 'aios-core');
+    this.excludes = options.excludes || [
+      'node_modules',
+      '.git',
+      '.aios',
+      'dist',
+      'build',
+      'coverage',
+      '.next',
+      '.nuxt',
+      'tmp',
+      'temp',
+    ];
+  }
+
+  /**
+   * Analyze complete framework structure
+   */
+  async analyzeFrameworkStructure(scope = 'full') {
+    const components = {
+      agents: [],
+      tasks: [],
+      workflows: [],
+      utils: [],
+      templates: [],
+      docs: [],
+      tests: [],
+    };
+
+    try {
+      // Analyze each component type based on scope
+      if (scope === 'full' || scope === 'agents') {
+        components.agents = await this.discoverAgents();
+      }
+
+      if (scope === 'full' || scope === 'tasks') {
+        components.tasks = await this.discoverTasks();
+      }
+
+      if (scope === 'full' || scope === 'workflows') {
+        components.workflows = await this.discoverWorkflows();
+      }
+
+      if (scope === 'full' || scope === 'utils') {
+        components.utils = await this.discoverUtils();
+      }
+
+      if (scope === 'full') {
+        components.templates = await this.discoverTemplates();
+        components.docs = await this.discoverDocs();
+        components.tests = await this.discoverTests();
+      }
+
+      // Calculate summary
+      const totalComponents = Object.values(components).reduce((sum, arr) => sum + arr.length, 0);
+
+      return {
+        scope,
+        timestamp: new Date().toISOString(),
+        total_components: totalComponents,
+        components: this.flattenComponents(components),
+        breakdown: components,
+        agents: components.agents,
+        tasks: components.tasks,
+        workflows: components.workflows,
+        utils: components.utils,
+        templates: components.templates,
+        docs: components.docs,
+        tests: components.tests,
+        directory_structure: await this.analyzeDirectoryStructure(),
+        dependencies: await this.analyzeDependencies(components),
+        metrics: await this.calculateFrameworkMetrics(components),
+      };
+    } catch (error) {
+      console.error(chalk.red(`Framework analysis failed: ${error.message}`));
+      throw error;
+    }
+  }
+
+  /**
+   * Discover all agents in the framework
+   */
+  async discoverAgents() {
+    const agents = [];
+    const agentsDir = path.join(this.aiosCoreDir, 'agents');
+
+    try {
+      await fs.access(agentsDir);
+      const files = await this.getMarkdownFiles(agentsDir);
+
+      for (const file of files) {
+        try {
+          const content = await fs.readFile(file, 'utf-8');
+          const agent = await this.parseAgentFile(file, content);
+          if (agent) agents.push(agent);
+        } catch (error) {
+          console.warn(chalk.yellow(`Warning: Failed to parse agent ${file}: ${error.message}`));
+        }
+      }
+    } catch (error) {
+      // Agents directory doesn't exist or not accessible
+    }
+
+    return agents;
+  }
+
+  /**
+   * Discover all tasks in the framework
+   */
+  async discoverTasks() {
+    const tasks = [];
+    const tasksDir = path.join(this.aiosCoreDir, 'tasks');
+
+    try {
+      await fs.access(tasksDir);
+      const files = await this.getMarkdownFiles(tasksDir);
+
+      for (const file of files) {
+        try {
+          const content = await fs.readFile(file, 'utf-8');
+          const task = await this.parseTaskFile(file, content);
+          if (task) tasks.push(task);
+        } catch (error) {
+          console.warn(chalk.yellow(`Warning: Failed to parse task ${file}: ${error.message}`));
+        }
+      }
+    } catch (error) {
+      // Tasks directory doesn't exist or not accessible
+    }
+
+    return tasks;
+  }
+
+  /**
+   * Discover all workflows in the framework
+   */
+  async discoverWorkflows() {
+    const workflows = [];
+    const workflowsDir = path.join(this.aiosCoreDir, 'workflows');
+
+    try {
+      await fs.access(workflowsDir);
+      const files = await this.getYamlFiles(workflowsDir);
+
+      for (const file of files) {
+        try {
+          const content = await fs.readFile(file, 'utf-8');
+          const workflow = await this.parseWorkflowFile(file, content);
+          if (workflow) workflows.push(workflow);
+        } catch (error) {
+          console.warn(chalk.yellow(`Warning: Failed to parse workflow ${file}: ${error.message}`));
+        }
+      }
+    } catch (error) {
+      // Workflows directory doesn't exist or not accessible
+    }
+
+    return workflows;
+  }
+
+  /**
+   * Discover all utilities in the framework
+   */
+  async discoverUtils() {
+    const utils = [];
+    const utilsDir = path.join(this.aiosCoreDir, 'utils');
+
+    try {
+      await fs.access(utilsDir);
+      const files = await this.getJavaScriptFiles(utilsDir);
+
+      for (const file of files) {
+        try {
+          const content = await fs.readFile(file, 'utf-8');
+          const util = await this.parseUtilFile(file, content);
+          if (util) utils.push(util);
+        } catch (error) {
+          console.warn(chalk.yellow(`Warning: Failed to parse util ${file}: ${error.message}`));
+        }
+      }
+    } catch (error) {
+      // Utils directory doesn't exist or not accessible
+    }
+
+    return utils;
+  }
+
+  /**
+   * Discover all templates in the framework
+   */
+  async discoverTemplates() {
+    const templates = [];
+    const templatesDir = path.join(this.aiosCoreDir, 'templates');
+
+    try {
+      await fs.access(templatesDir);
+      const files = await this.getAllFiles(templatesDir);
+
+      for (const file of files) {
+        try {
+          const template = await this.parseTemplateFile(file);
+          if (template) templates.push(template);
+        } catch (error) {
+          console.warn(chalk.yellow(`Warning: Failed to parse template ${file}: ${error.message}`));
+        }
+      }
+    } catch (error) {
+      // Templates directory doesn't exist or not accessible
+    }
+
+    return templates;
+  }
+
+  /**
+   * Discover documentation files
+   */
+  async discoverDocs() {
+    const docs = [];
+    const docsDir = path.join(this.rootPath, 'docs');
+
+    try {
+      await fs.access(docsDir);
+      const files = await this.getMarkdownFiles(docsDir);
+
+      for (const file of files) {
+        try {
+          const doc = await this.parseDocFile(file);
+          if (doc) docs.push(doc);
+        } catch (error) {
+          console.warn(chalk.yellow(`Warning: Failed to parse doc ${file}: ${error.message}`));
+        }
+      }
+    } catch (error) {
+      // Docs directory doesn't exist or not accessible
+    }
+
+    return docs;
+  }
+
+  /**
+   * Discover test files
+   */
+  async discoverTests() {
+    const tests = [];
+    const testsDir = path.join(this.rootPath, 'tests');
+
+    try {
+      await fs.access(testsDir);
+      const files = await this.getJavaScriptFiles(testsDir);
+
+      for (const file of files) {
+        try {
+          const test = await this.parseTestFile(file);
+          if (test) tests.push(test);
+        } catch (error) {
+          console.warn(chalk.yellow(`Warning: Failed to parse test ${file}: ${error.message}`));
+        }
+      }
+    } catch (error) {
+      // Tests directory doesn't exist or not accessible
+    }
+
+    return tests;
+  }
+
+  /**
+   * Parse agent file content
+   */
+  async parseAgentFile(filePath, content) {
+    try {
+      // Extract YAML frontmatter
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      let metadata = {};
+      
+      if (frontmatterMatch) {
+        metadata = yaml.load(frontmatterMatch[1]) || {};
+      }
+
+      // Extract markdown content
+      const markdownContent = content.replace(/^---\n[\s\S]*?\n---\n/, '');
+      
+      return {
+        type: 'agent',
+        id: metadata.id || path.basename(filePath, '.md'),
+        name: metadata.name || path.basename(filePath, '.md'),
+        description: metadata.description || this.extractDescription(markdownContent),
+        version: metadata.version || '1.0.0',
+        file_path: path.relative(this.rootPath, filePath),
+        size: content.length,
+        last_modified: (await fs.stat(filePath)).mtime,
+        metadata,
+        dependencies: this.extractDependencies(content),
+        capabilities: metadata.capabilities || [],
+        complexity: this.calculateComplexity(content),
+        maintainability: this.calculateMaintainability(content),
+      };
+    } catch (error) {
+      console.warn(`Failed to parse agent ${filePath}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Parse task file content
+   */
+  async parseTaskFile(filePath, content) {
+    try {
+      // Tasks use different structure than agents
+      const nameMatch = content.match(/^# Task: (.+)$/m);
+      const descMatch = content.match(/## Description\n([\s\S]*?)(?=\n## |$)/);
+      const typeMatch = content.match(/## Type\n(.+)$/m);
+      const complexityMatch = content.match(/## Complexity\n(.+)$/m);
+
+      return {
+        type: 'task',
+        id: path.basename(filePath, '.md'),
+        name: nameMatch ? nameMatch[1].trim() : path.basename(filePath, '.md'),
+        description: descMatch ? descMatch[1].trim() : '',
+        task_type: typeMatch ? typeMatch[1].trim() : 'unknown',
+        complexity: complexityMatch ? complexityMatch[1].trim().toLowerCase() : 'medium',
+        file_path: path.relative(this.rootPath, filePath),
+        size: content.length,
+        last_modified: (await fs.stat(filePath)).mtime,
+        dependencies: this.extractDependencies(content),
+        parameters: this.extractTaskParameters(content),
+        implementation_status: this.analyzeImplementationStatus(content),
+      };
+    } catch (error) {
+      console.warn(`Failed to parse task ${filePath}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Parse workflow file content
+   */
+  async parseWorkflowFile(filePath, content) {
+    try {
+      const workflow = yaml.load(content);
+      
+      return {
+        type: 'workflow',
+        id: workflow.id || path.basename(filePath, '.yaml'),
+        name: workflow.name || path.basename(filePath, '.yaml'),
+        description: workflow.description || '',
+        version: workflow.version || '1.0.0',
+        file_path: path.relative(this.rootPath, filePath),
+        size: content.length,
+        last_modified: (await fs.stat(filePath)).mtime,
+        steps: workflow.steps || [],
+        dependencies: workflow.dependencies || [],
+        triggers: workflow.triggers || [],
+        complexity: this.calculateWorkflowComplexity(workflow),
+        validation_status: await this.validateWorkflow(workflow),
+      };
+    } catch (error) {
+      console.warn(`Failed to parse workflow ${filePath}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Parse utility file content
+   */
+  async parseUtilFile(filePath, content) {
+    try {
+      const stats = await fs.stat(filePath);
+      
+      return {
+        type: 'utility',
+        id: path.basename(filePath, '.js'),
+        name: path.basename(filePath),
+        description: this.extractUtilDescription(content),
+        file_path: path.relative(this.rootPath, filePath),
+        size: content.length,
+        last_modified: stats.mtime,
+        exports: this.extractExports(content),
+        functions: this.extractFunctions(content),
+        dependencies: this.extractImports(content),
+        complexity: this.calculateCodeComplexity(content),
+        test_coverage: await this.calculateTestCoverage(filePath),
+      };
+    } catch (error) {
+      console.warn(`Failed to parse util ${filePath}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Parse template file
+   */
+  async parseTemplateFile(filePath) {
+    try {
+      const stats = await fs.stat(filePath);
+      const content = await fs.readFile(filePath, 'utf-8');
+      
+      return {
+        type: 'template',
+        id: path.basename(filePath),
+        name: path.basename(filePath),
+        description: this.extractTemplateDescription(content),
+        file_path: path.relative(this.rootPath, filePath),
+        size: content.length,
+        last_modified: stats.mtime,
+        template_type: this.detectTemplateType(filePath, content),
+        variables: this.extractTemplateVariables(content),
+      };
+    } catch (error) {
+      console.warn(`Failed to parse template ${filePath}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Parse documentation file
+   */
+  async parseDocFile(filePath) {
+    try {
+      const stats = await fs.stat(filePath);
+      const content = await fs.readFile(filePath, 'utf-8');
+      
+      return {
+        type: 'documentation',
+        id: path.basename(filePath, '.md'),
+        name: path.basename(filePath),
+        description: this.extractDescription(content),
+        file_path: path.relative(this.rootPath, filePath),
+        size: content.length,
+        last_modified: stats.mtime,
+        doc_type: this.detectDocType(filePath),
+        sections: this.extractSections(content),
+        word_count: this.countWords(content),
+      };
+    } catch (error) {
+      console.warn(`Failed to parse doc ${filePath}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Parse test file
+   */
+  async parseTestFile(filePath) {
+    try {
+      const stats = await fs.stat(filePath);
+      const content = await fs.readFile(filePath, 'utf-8');
+      
+      return {
+        type: 'test',
+        id: path.basename(filePath, '.js'),
+        name: path.basename(filePath),
+        description: this.extractTestDescription(content),
+        file_path: path.relative(this.rootPath, filePath),
+        size: content.length,
+        last_modified: stats.mtime,
+        test_framework: this.detectTestFramework(content),
+        test_suites: this.extractTestSuites(content),
+        test_count: this.countTests(content),
+        coverage_target: this.extractCoverageTarget(filePath),
+      };
+    } catch (error) {
+      console.warn(`Failed to parse test ${filePath}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Analyze directory structure
+   */
+  async analyzeDirectoryStructure() {
+    const structure = {
+      total_directories: 0,
+      total_files: 0,
+      depth: 0,
+      size_distribution: {},
+      file_types: {},
+    };
+
+    try {
+      await this.walkDirectory(this.rootPath, structure, 0);
+    } catch (error) {
+      console.warn(`Directory analysis failed: ${error.message}`);
+    }
+
+    return structure;
+  }
+
+  /**
+   * Analyze component dependencies
+   */
+  async analyzeDependencies(components) {
+    const dependencies = {
+      internal: new Map(),
+      external: new Map(),
+      circular: [],
+      orphaned: [],
+      highly_coupled: [],
+    };
+
+    // Analyze dependencies for each component type
+    const allComponents = this.flattenComponents(components);
+    
+    for (const component of allComponents) {
+      if (component.dependencies) {
+        for (const dep of component.dependencies) {
+          if (this.isInternalDependency(dep)) {
+            dependencies.internal.set(dep, (dependencies.internal.get(dep) || 0) + 1);
+          } else {
+            dependencies.external.set(dep, (dependencies.external.get(dep) || 0) + 1);
+          }
+        }
+      }
+    }
+
+    // Detect circular dependencies
+    dependencies.circular = await this.detectCircularDependencies(allComponents);
+    
+    // Find orphaned components
+    dependencies.orphaned = this.findOrphanedComponents(allComponents);
+    
+    // Find highly coupled components
+    dependencies.highly_coupled = this.findHighlyCoupledComponents(allComponents);
+
+    return {
+      internal_count: dependencies.internal.size,
+      external_count: dependencies.external.size,
+      internal_dependencies: Array.from(dependencies.internal.entries()).map(([name, count]) => ({ name, count })),
+      external_dependencies: Array.from(dependencies.external.entries()).map(([name, count]) => ({ name, count })),
+      circular_dependencies: dependencies.circular,
+      orphaned_components: dependencies.orphaned,
+      highly_coupled_components: dependencies.highly_coupled,
+    };
+  }
+
+  /**
+   * Calculate framework-wide metrics
+   */
+  async calculateFrameworkMetrics(components) {
+    const allComponents = this.flattenComponents(components);
+    
+    return {
+      total_size: allComponents.reduce((sum, comp) => sum + (comp.size || 0), 0),
+      average_complexity: this.calculateAverageComplexity(allComponents),
+      maintainability_index: this.calculateMaintainabilityIndex(allComponents),
+      test_coverage: await this.calculateOverallTestCoverage(components),
+      documentation_coverage: this.calculateDocumentationCoverage(components),
+      code_quality_score: this.calculateCodeQualityScore(allComponents),
+      technical_debt: this.calculateTechnicalDebt(allComponents),
+    };
+  }
+
+  // File discovery helper methods
+  async getMarkdownFiles(dir) {
+    return this.getFilesByExtension(dir, '.md');
+  }
+
+  async getYamlFiles(dir) {
+    return this.getFilesByExtension(dir, ['.yaml', '.yml']);
+  }
+
+  async getJavaScriptFiles(dir) {
+    return this.getFilesByExtension(dir, ['.js', '.mjs']);
+  }
+
+  async getAllFiles(dir) {
+    const files = [];
+    await this.walkDirectory(dir, { files }, 0);
+    return files;
+  }
+
+  async getFilesByExtension(dir, extensions) {
+    const files = [];
+    const extArray = Array.isArray(extensions) ? extensions : [extensions];
+    
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        
+        if (entry.isDirectory() && !this.isExcluded(entry.name)) {
+          files.push(...await this.getFilesByExtension(fullPath, extensions));
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name).toLowerCase();
+          if (extArray.includes(ext)) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch (error) {
+      // Directory not accessible
+    }
+    
+    return files;
+  }
+
+  async walkDirectory(dir, result, depth) {
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      result.depth = Math.max(result.depth || 0, depth);
+      
+      for (const entry of entries) {
+        if (this.isExcluded(entry.name)) continue;
+        
+        const fullPath = path.join(dir, entry.name);
+        
+        if (entry.isDirectory()) {
+          result.total_directories = (result.total_directories || 0) + 1;
+          await this.walkDirectory(fullPath, result, depth + 1);
+        } else if (entry.isFile()) {
+          result.total_files = (result.total_files || 0) + 1;
+          
+          if (result.files) {
+            result.files.push(fullPath);
+          }
+          
+          // Track file types
+          const ext = path.extname(entry.name).toLowerCase();
+          result.file_types = result.file_types || {};
+          result.file_types[ext] = (result.file_types[ext] || 0) + 1;
+          
+          // Track size distribution
+          const stats = await fs.stat(fullPath);
+          const sizeCategory = this.getSizeCategory(stats.size);
+          result.size_distribution = result.size_distribution || {};
+          result.size_distribution[sizeCategory] = (result.size_distribution[sizeCategory] || 0) + 1;
+        }
+      }
+    } catch (error) {
+      // Directory not accessible
+    }
+  }
+
+  // Helper methods
+  isExcluded(name) {
+    return this.excludes.some(exclude => 
+      name === exclude || 
+      name.startsWith(exclude) || 
+      name.startsWith('.'),
+    );
+  }
+
+  flattenComponents(components) {
+    return Object.values(components).flat();
+  }
+
+  extractDescription(content) {
+    // Extract first paragraph or first meaningful line
+    const lines = content.split('\n').filter(line => line.trim());
+    return lines.find(line => line.length > 20 && !line.startsWith('#')) || '';
+  }
+
+  extractDependencies(content) {
+    const deps = [];
+    const requireMatches = content.match(/require\(['"`]([^'"`]+)['"`]\)/g) || [];
+    const importMatches = content.match(/import .* from ['"`]([^'"`]+)['"`]/g) || [];
+    
+    requireMatches.forEach(match => {
+      const dep = match.match(/['"`]([^'"`]+)['"`]/)[1];
+      if (!deps.includes(dep)) deps.push(dep);
+    });
+    
+    importMatches.forEach(match => {
+      const dep = match.match(/from ['"`]([^'"`]+)['"`]/)[1];
+      if (!deps.includes(dep)) deps.push(dep);
+    });
+    
+    return deps;
+  }
+
+  calculateComplexity(content) {
+    // Simple complexity calculation based on content patterns
+    const lines = content.split('\n').length;
+    const functions = (content.match(/function|async|=>/g) || []).length;
+    const conditions = (content.match(/if|while|for|switch|catch/g) || []).length;
+    const complexity = Math.min(10, (functions + conditions * 2) / lines * 100);
+    return Math.max(1, Math.round(complexity));
+  }
+
+  calculateMaintainability(content) {
+    // Basic maintainability score
+    const lines = content.split('\n').length;
+    const comments = (content.match(/\/\*[\s\S]*?\*\/|\/\/.*/g) || []).length;
+    const commentRatio = comments / lines;
+    const maintainability = Math.min(10, 5 + commentRatio * 10);
+    return Math.round(maintainability * 10) / 10;
+  }
+
+  getSizeCategory(size) {
+    if (size < 1024) return 'tiny';
+    if (size < 10240) return 'small';
+    if (size < 102400) return 'medium';
+    if (size < 1048576) return 'large';
+    return 'huge';
+  }
+
+  isInternalDependency(dep) {
+    return dep.startsWith('./') || dep.startsWith('../') || dep.startsWith('/');
+  }
+
+  // Stub methods for more complex analysis
+  extractTaskParameters(content) { return []; }
+  analyzeImplementationStatus(content) { return 'unknown'; }
+  calculateWorkflowComplexity(workflow) { return 1; }
+  validateWorkflow(workflow) { return { valid: true }; }
+  extractUtilDescription(content) { return ''; }
+  extractExports(content) { return []; }
+  extractFunctions(content) { return []; }
+  extractImports(content) { return []; }
+  calculateCodeComplexity(content) { return 1; }
+  calculateTestCoverage(filePath) { return 0; }
+  extractTemplateDescription(content) { return ''; }
+  detectTemplateType(filePath, content) { return 'generic'; }
+  extractTemplateVariables(content) { return []; }
+  detectDocType(filePath) { return 'general'; }
+  extractSections(content) { return []; }
+  countWords(content) { return content.split(/\s+/).length; }
+  extractTestDescription(content) { return ''; }
+  detectTestFramework(content) { return 'jest'; }
+  extractTestSuites(content) { return []; }
+  countTests(content) { return (content.match(/test\(|it\(/g) || []).length; }
+  extractCoverageTarget(filePath) { return null; }
+  detectCircularDependencies(components) { return []; }
+  findOrphanedComponents(components) { return []; }
+  findHighlyCoupledComponents(components) { return []; }
+  calculateAverageComplexity(components) { return 1; }
+  calculateMaintainabilityIndex(components) { return 80; }
+  calculateOverallTestCoverage(components) { return 0; }
+  calculateDocumentationCoverage(components) { return 0; }
+  calculateCodeQualityScore(components) { return 7; }
+  calculateTechnicalDebt(components) { return 'low'; }
+}
+
+module.exports = FrameworkAnalyzer;