create-genia-os 2.4.0 → 3.0.0

package/template/.aiox-core/development/scripts/validate-filenames.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+/**
+ * Validate Architecture and PRD Filenames
+ *
+ * Ensures all sharded documentation files follow English naming conventions
+ * and don't contain Portuguese characters or untranslated terms.
+ *
+ * Usage:
+ *   node .aiox-core/utils/validate-filenames.js
+ *   node .aiox-core/utils/validate-filenames.js --fix
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Portuguese characters that should not appear in filenames
+const PORTUGUESE_CHARS = /[áàâãéêíóôõúüç]/i;
+
+// Common Portuguese terms that should be translated
+const PORTUGUESE_TERMS = {
+  'visao': 'vision',
+  'viso': 'vision',
+  'produto': 'product',
+  'problema': 'problem',
+  'objetivos': 'objectives',
+  'glossario': 'glossary',
+  'glossrio': 'glossary',
+  'terminologia': 'terminology',
+  'premissas': 'assumptions',
+  'restricoes': 'constraints',
+  'restries': 'constraints',
+  'stakeholders': 'stakeholders', // OK
+  'requisitos': 'requirements',
+  'arquitetura': 'architecture',
+  'tecnologia': 'technology',
+  'pilha': 'stack',
+  'padroes': 'standards',
+  'padres': 'standards',
+  'estrutura': 'structure',
+  'arvore': 'tree',
+  'seguranca': 'security',
+  'desempenho': 'performance',
+  'escalabilidade': 'scalability',
+  'confiabilidade': 'reliability',
+  'conformidade': 'compliance',
+  'riscos': 'risks',
+  'tecnicos': 'technical',
+  'tecnico': 'technical',
+  'negocio': 'business',
+  'negcios': 'business',
+  'infraestrutura': 'infrastructure',
+  'dados': 'data',
+  'banco': 'database',
+  'esquema': 'schema',
+  'testes': 'tests',
+  'estrategia': 'strategy',
+  'estratgia': 'strategy',
+  'metadados': 'metadata',
+  'indice': 'index',
+  'ndice': 'index',
+  'decisoes': 'decisions',
+  'decises': 'decisions',
+  'decisao': 'decision',
+  'deciso': 'decision'
+};
+
+// Expected standard filenames (architecture)
+const STANDARD_FILES = [
+  'tech-stack.md',
+  'coding-standards.md',
+  'source-tree.md',
+  'project-structure.md',
+  'unified-project-structure.md',
+  'testing-strategy.md',
+  'database-schema.md',
+  'data-models.md',
+  'api-design.md',
+  'architecture-diagram.md'
+];
+
+class FilenameValidator {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.errors = [];
+    this.warnings = [];
+  }
+
+  validateDirectory(dir) {
+    if (!fs.existsSync(dir)) {
+      this.warnings.push(`Directory not found: ${dir}`);
+      return;
+    }
+
+    const files = fs.readdirSync(dir);
+
+    for (const file of files) {
+      if (!file.endsWith('.md')) continue;
+      if (file === 'index.md') continue; // index.md is always OK
+
+      this.validateFilename(file, dir);
+    }
+  }
+
+  validateFilename(filename, directory) {
+    const basename = path.basename(filename, '.md');
+
+    // Check for Portuguese characters
+    if (PORTUGUESE_CHARS.test(basename)) {
+      this.errors.push({
+        file: path.join(directory, filename),
+        issue: 'Contains Portuguese characters (accents)',
+        suggestion: this.removeAccents(basename) + '.md'
+      });
+      return;
+    }
+
+    // Check for Portuguese terms
+    const lowerBasename = basename.toLowerCase();
+    for (const [ptTerm, enTerm] of Object.entries(PORTUGUESE_TERMS)) {
+      if (lowerBasename.includes(ptTerm) && !STANDARD_FILES.includes(filename)) {
+        const suggested = lowerBasename.replace(new RegExp(ptTerm, 'g'), enTerm);
+        this.errors.push({
+          file: path.join(directory, filename),
+          issue: `Contains Portuguese term: "${ptTerm}"`,
+          suggestion: suggested + '.md'
+        });
+      }
+    }
+  }
+
+  removeAccents(str) {
+    return str
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .toLowerCase();
+  }
+
+  report() {
+    console.log('\n📋 AIOX Filename Validation Report\n');
+    console.log('=' .repeat(60));
+
+    if (this.errors.length === 0 && this.warnings.length === 0) {
+      console.log('✅ All filenames are valid!\n');
+      return true;
+    }
+
+    if (this.warnings.length > 0) {
+      console.log('\n⚠️  Warnings:\n');
+      this.warnings.forEach(warning => {
+        console.log(`   ${warning}`);
+      });
+    }
+
+    if (this.errors.length > 0) {
+      console.log('\n❌ Errors found:\n');
+      this.errors.forEach((error, index) => {
+        console.log(`   ${index + 1}. ${error.file}`);
+        console.log(`      Issue: ${error.issue}`);
+        console.log(`      Suggest: ${error.suggestion}\n`);
+      });
+
+      console.log(`\n${this.errors.length} filename(s) need correction.\n`);
+      console.log('To fix these issues:');
+      console.log('1. Re-run the shard task with updated translation rules');
+      console.log('2. Or manually rename the files using the suggestions above');
+      console.log('3. Or run: node .aiox-core/utils/validate-filenames.js --fix\n');
+
+      return false;
+    }
+
+    return true;
+  }
+
+  fix() {
+    console.log('\n🔧 Fixing filename issues...\n');
+
+    let fixed = 0;
+    for (const error of this.errors) {
+      const oldPath = error.file;
+      const dir = path.dirname(oldPath);
+      const newPath = path.join(dir, error.suggestion);
+
+      try {
+        fs.renameSync(oldPath, newPath);
+        console.log(`✅ Renamed: ${path.basename(oldPath)} → ${path.basename(newPath)}`);
+        fixed++;
+      } catch (err) {
+        console.error(`❌ Failed to rename ${oldPath}: ${err.message}`);
+      }
+    }
+
+    console.log(`\n✨ Fixed ${fixed} of ${this.errors.length} files.\n`);
+  }
+
+  validate() {
+    console.log('🔍 Validating documentation filenames...\n');
+
+    // Check docs/architecture/
+    const archDir = path.join(this.projectRoot, 'docs', 'architecture');
+    console.log(`Checking: ${archDir}`);
+    this.validateDirectory(archDir);
+
+    // Check docs/prd/
+    const prdDir = path.join(this.projectRoot, 'docs', 'prd');
+    console.log(`Checking: ${prdDir}`);
+    this.validateDirectory(prdDir);
+
+    return this.report();
+  }
+}
+
+// Main execution
+const projectRoot = process.cwd();
+const shouldFix = process.argv.includes('--fix');
+
+const validator = new FilenameValidator(projectRoot);
+const isValid = validator.validate();
+
+if (shouldFix && !isValid) {
+  validator.fix();
+  // Re-validate
+  const validator2 = new FilenameValidator(projectRoot);
+  validator2.validate();
+}
+
+process.exit(isValid ? 0 : 1);

package/template/.aiox-core/development/scripts/validate-task-v2.js

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+
+/**
+ * Task Format V2.0 Validation Script
+ * 
+ * Validates task files against the V2.0 specification with 11 compliance rules.
+ * 
+ * Usage:
+ *   node validate-task-v2.js <task-file>          # Validate single task
+ *   node validate-task-v2.js --all                # Validate all tasks
+ * 
+ * Exit codes:
+ *   0 = All tasks compliant
+ *   1 = Some tasks non-compliant
+ *   2 = Error during validation
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ANSI color codes
+const colors = {
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  reset: '\x1b[0m',
+};
+
+/**
+ * Validation rules for V2.0 compliance
+ */
+const validationRules = [
+  {
+    id: 1,
+    name: 'Execution Modes section',
+    check: (content) => {
+      return content.includes('## Execution Modes') || 
+             content.includes('# Execution Modes');
+    },
+    message: 'Missing "Execution Modes" section',
+  },
+  {
+    id: 2,
+    name: 'Task Definition YAML format',
+    check: (content) => {
+      return content.includes('task:') && 
+             content.includes('responsável:') &&
+             content.includes('responsavel_type:') &&
+             content.includes('atomic_layer:');
+    },
+    message: 'Task Definition incomplete (missing task, responsável, responsavel_type, or atomic_layer)',
+  },
+  {
+    id: 3,
+    name: 'Entrada and Saída defined',
+    check: (content) => {
+      return content.includes('**Entrada:**') && 
+             content.includes('**Saída:**');
+    },
+    message: 'Missing Entrada or Saída sections',
+  },
+  {
+    id: 4,
+    name: 'Checklist restructured',
+    check: (content) => {
+      return content.includes('pre-conditions:') && 
+             content.includes('post-conditions:') &&
+             content.includes('acceptance-criteria:');
+    },
+    message: 'Checklist not restructured (missing pre-conditions, post-conditions, or acceptance-criteria)',
+  },
+  {
+    id: 5,
+    name: 'Checklist items have required fields',
+    check: (content) => {
+      const hasType = content.includes('tipo:');
+      const hasBlocker = content.includes('blocker:');
+      const hasValidation = content.includes('validação:') || content.includes('validation:');
+      return hasType && hasBlocker && hasValidation;
+    },
+    message: 'Checklist items missing required fields (tipo, blocker, validação)',
+  },
+  {
+    id: 6,
+    name: 'Tools section present',
+    check: (content) => {
+      return content.includes('## Tools') || 
+             content.includes('**Tools:**') ||
+             content.includes('- N/A') && content.toLowerCase().includes('tool');
+    },
+    message: 'Missing Tools section',
+  },
+  {
+    id: 7,
+    name: 'Scripts section present',
+    check: (content) => {
+      return content.includes('## Scripts') || 
+             content.includes('**Scripts:**') ||
+             content.includes('- N/A') && content.toLowerCase().includes('script');
+    },
+    message: 'Missing Scripts section',
+  },
+  {
+    id: 8,
+    name: 'Performance section present',
+    check: (content) => {
+      return content.includes('## Performance') ||
+             content.includes('**Performance:**') ||
+             (content.includes('duration_expected:') && content.includes('cost_estimated:'));
+    },
+    message: 'Missing Performance section or required metrics (duration_expected, cost_estimated)',
+  },
+  {
+    id: 9,
+    name: 'Error Handling section present',
+    check: (content) => {
+      return (content.includes('## Error Handling') || content.includes('**Error Handling:**')) &&
+             (content.includes('strategy:') || content.includes('Strategy:'));
+    },
+    message: 'Missing Error Handling section or strategy not defined',
+  },
+  {
+    id: 10,
+    name: 'Metadata section present',
+    check: (content) => {
+      return (content.includes('## Metadata') || content.includes('**Metadata:**')) &&
+             content.includes('story:') &&
+             content.includes('version:');
+    },
+    message: 'Missing Metadata section or required fields (story, version)',
+  },
+  {
+    id: 11,
+    name: 'Standardized output template',
+    check: (content) => {
+      // Check for output template markers (less strict as this might be in separate template file)
+      return content.includes('Duration:') || 
+             content.includes('Tokens Used:') ||
+             content.includes('Metrics') ||
+             content.includes('task-execution-report');
+    },
+    message: 'Output template markers not found (Duration, Tokens, Metrics)',
+  },
+];
+
+/**
+ * Validate a single task file
+ * @param {string} filePath - Path to the task file
+ * @returns {Object} Validation result
+ */
+function validateTask(filePath) {
+  const fileName = path.basename(filePath);
+  const result = {
+    file: fileName,
+    path: filePath,
+    compliant: true,
+    passed: [],
+    failed: [],
+  };
+
+  try {
+    // Read file content
+    const content = fs.readFileSync(filePath, 'utf8');
+
+    // Run all validation rules
+    for (const rule of validationRules) {
+      const passed = rule.check(content);
+      
+      if (passed) {
+        result.passed.push({
+          id: rule.id,
+          name: rule.name,
+        });
+      } else {
+        result.failed.push({
+          id: rule.id,
+          name: rule.name,
+          message: rule.message,
+        });
+        result.compliant = false;
+      }
+    }
+
+  } catch (error) {
+    result.compliant = false;
+    result.error = error.message;
+  }
+
+  return result;
+}
+
+/**
+ * Validate all tasks in .aiox-core/tasks/
+ * @returns {Object} Summary of validation results
+ */
+function validateAllTasks() {
+  const tasksDir = path.join(process.cwd(), '.aiox-core', 'tasks');
+  
+  if (!fs.existsSync(tasksDir)) {
+    console.error(`${colors.red}✗ Tasks directory not found: ${tasksDir}${colors.reset}`);
+    process.exit(2);
+  }
+
+  const taskFiles = fs.readdirSync(tasksDir)
+    .filter(file => file.endsWith('.md') && !file.includes('.v1-backup.md'))
+    .map(file => path.join(tasksDir, file));
+
+  console.log(`${colors.cyan}Validating ${taskFiles.length} tasks...${colors.reset}\n`);
+
+  const results = taskFiles.map(validateTask);
+  const compliantCount = results.filter(r => r.compliant).length;
+  const nonCompliantCount = results.length - compliantCount;
+
+  // Group results by phases (approximate)
+  const phase1 = results.slice(0, 15);
+  const phase2 = results.slice(15, 65);
+  const phase3 = results.slice(65);
+
+  const phase1Compliant = phase1.filter(r => r.compliant).length;
+  const phase2Compliant = phase2.filter(r => r.compliant).length;
+  const phase3Compliant = phase3.filter(r => r.compliant).length;
+
+  console.log(`${colors.cyan}Phase Results:${colors.reset}`);
+  console.log(`${phase1Compliant === phase1.length ? colors.green + '✅' : colors.red + '✗'} Phase 1: ${phase1Compliant}/${phase1.length} tasks compliant${colors.reset}`);
+  console.log(`${phase2Compliant === phase2.length ? colors.green + '✅' : colors.red + '✗'} Phase 2: ${phase2Compliant}/${phase2.length} tasks compliant${colors.reset}`);
+  console.log(`${phase3Compliant === phase3.length ? colors.green + '✅' : colors.red + '✗'} Phase 3: ${phase3Compliant}/${phase3.length} tasks compliant${colors.reset}`);
+  console.log();
+
+  // Show overall result
+  if (compliantCount === results.length) {
+    console.log(`${colors.green}✅ RESULT: ${compliantCount}/${results.length} tasks V2.0 compliant${colors.reset}\n`);
+  } else {
+    console.log(`${colors.red}✗ RESULT: ${compliantCount}/${results.length} tasks compliant, ${nonCompliantCount} non-compliant${colors.reset}\n`);
+    
+    // Show non-compliant tasks
+    console.log(`${colors.yellow}Non-compliant tasks:${colors.reset}`);
+    results.filter(r => !r.compliant).forEach(result => {
+      console.log(`  ${colors.red}✗${colors.reset} ${result.file}`);
+      result.failed.forEach(failure => {
+        console.log(`     - Rule ${failure.id}: ${failure.message}`);
+      });
+    });
+  }
+
+  return {
+    total: results.length,
+    compliant: compliantCount,
+    nonCompliant: nonCompliantCount,
+    results,
+  };
+}
+
+/**
+ * Print validation result for a single task
+ * @param {Object} result - Validation result
+ */
+function printResult(result) {
+  if (result.error) {
+    console.log(`${colors.red}✗ ERROR: ${result.file}${colors.reset}`);
+    console.log(`   ${result.error}\n`);
+    return;
+  }
+
+  if (result.compliant) {
+    console.log(`${colors.green}✅ PASS: ${result.file}${colors.reset}`);
+    result.passed.forEach(rule => {
+      console.log(`   ${colors.green}✓${colors.reset} ${rule.name}`);
+    });
+  } else {
+    console.log(`${colors.red}✗ FAIL: ${result.file}${colors.reset}`);
+    result.failed.forEach(failure => {
+      console.log(`   ${colors.red}✗${colors.reset} Rule ${failure.id}: ${failure.message}`);
+    });
+    if (result.passed.length > 0) {
+      console.log(`   ${colors.green}Passed: ${result.passed.length}/${validationRules.length} rules${colors.reset}`);
+    }
+  }
+  console.log();
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.log('Usage:');
+    console.log('  node validate-task-v2.js <task-file>    # Validate single task');
+    console.log('  node validate-task-v2.js --all          # Validate all tasks');
+    process.exit(0);
+  }
+
+  if (args[0] === '--all') {
+    const summary = validateAllTasks();
+    process.exit(summary.nonCompliant > 0 ? 1 : 0);
+  } else {
+    const taskFile = args[0];
+    
+    if (!fs.existsSync(taskFile)) {
+      console.error(`${colors.red}✗ File not found: ${taskFile}${colors.reset}`);
+      process.exit(2);
+    }
+
+    const result = validateTask(taskFile);
+    printResult(result);
+    
+    process.exit(result.compliant ? 0 : 1);
+  }
+}
+
+// Run if executed directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { validateTask, validateAllTasks, validationRules };
+