aios-core 3.9.6 → 3.11.0

package/.aios-core/cli/commands/validate/index.js

@@ -0,0 +1,429 @@
+/**
+ * Validate Command Module
+ *
+ * CLI command for validating AIOS-Core installation integrity.
+ * Compares installed files against the install manifest.
+ *
+ * @module cli/commands/validate
+ * @version 1.0.0
+ * @story 6.19 - Post-Installation Validation & Integrity Verification
+ *
+ * Usage:
+ *   aios validate                    # Validate current installation
+ *   aios validate --repair           # Repair missing/corrupted files
+ *   aios validate --repair --dry-run # Preview repairs without applying
+ *   aios validate --detailed         # Show detailed file list
+ *   aios validate --json             # Output as JSON
+ */
+
+'use strict';
+
+const { Command } = require('commander');
+const path = require('path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const ora = require('ora');
+
+/**
+ * Exit codes for CLI consistency
+ * @enum {number}
+ */
+const ExitCode = {
+  SUCCESS: 0,
+  VALIDATION_FAILED: 1,
+  ERROR: 2,
+};
+
+// Resolve validator module path
+const validatorPath = path.resolve(__dirname, '../../../../src/installer/post-install-validator');
+let PostInstallValidator, formatReport;
+
+let validatorLoadError = null;
+try {
+  const validator = require(validatorPath);
+  PostInstallValidator = validator.PostInstallValidator;
+  formatReport = validator.formatReport;
+} catch (error) {
+  // Store error for later - will be reported during command execution
+  // This allows proper JSON output when --json flag is used
+  validatorLoadError = error;
+}
+
+/**
+ * Create the validate command
+ * @returns {Command} Commander command instance
+ */
+function createValidateCommand() {
+  const validate = new Command('validate');
+
+  validate
+    .description('Validate AIOS-Core installation integrity')
+    .option('-r, --repair', 'Repair missing or corrupted files')
+    .option('-d, --dry-run', 'Preview repairs without applying (use with --repair)')
+    .option('--detailed', 'Show detailed file list')
+    .option('--no-hash', 'Skip hash verification (faster)')
+    .option('--extras', 'Detect extra files not in manifest')
+    .option('-v, --verbose', 'Enable verbose output')
+    .option('--json', 'Output results as JSON')
+    .option('--source <dir>', 'Source directory for repairs')
+    .addHelpText(
+      'after',
+      `
+Examples:
+  ${chalk.dim('# Validate current installation')}
+  $ aios validate
+
+  ${chalk.dim('# Validate with detailed file list')}
+  $ aios validate --detailed
+
+  ${chalk.dim('# Repair missing/corrupted files')}
+  $ aios validate --repair
+
+  ${chalk.dim('# Preview what would be repaired')}
+  $ aios validate --repair --dry-run
+
+  ${chalk.dim('# Quick validation (skip hash check)')}
+  $ aios validate --no-hash
+
+  ${chalk.dim('# Output as JSON for CI/CD')}
+  $ aios validate --json
+
+Exit Codes:
+  0 - Validation passed
+  1 - Validation failed (missing/corrupted files)
+  2 - Validation error (could not complete)
+`
+    )
+    .action(async (options) => {
+      await runValidation(options);
+    });
+
+  return validate;
+}
+
+/**
+ * Run the validation process
+ * @param {Object} options - Command options
+ */
+async function runValidation(options) {
+  const projectRoot = process.cwd();
+  const aiosCoreDir = path.join(projectRoot, '.aios-core');
+
+  // Check if AIOS-Core is installed
+  if (!fs.existsSync(aiosCoreDir)) {
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            status: 'failed',
+            error: 'AIOS-Core not found in current directory',
+            // SECURITY: Sanitize path - only show relative indicator
+            location: '.aios-core',
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk.red('\nError: AIOS-Core not found in current directory'));
+      console.error(chalk.dim(`Expected at: ${aiosCoreDir}`));
+      console.error(chalk.dim('\nRun `npx aios-core install` to install AIOS-Core'));
+    }
+    process.exit(ExitCode.ERROR);
+  }
+
+  // Check if validator module is available
+  if (!PostInstallValidator) {
+    const errorMsg = validatorLoadError
+      ? `Validator module failed to load: ${validatorLoadError.message}`
+      : 'Validator module not available';
+
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            status: 'error',
+            error: errorMsg,
+            hint: 'This may indicate a corrupted installation',
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk.red(`\nError: ${errorMsg}`));
+      console.error(chalk.dim('This may indicate a corrupted installation'));
+    }
+    process.exit(ExitCode.ERROR);
+  }
+
+  // Determine source directory for repairs
+  let sourceDir = options.source;
+
+  // SECURITY: Validate --source directory if provided
+  if (sourceDir) {
+    const sourceManifest = path.join(sourceDir, '.aios-core', 'install-manifest.yaml');
+    if (!fs.existsSync(sourceManifest)) {
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              status: 'error',
+              error: 'Invalid source directory: manifest not found',
+              path: sourceDir,
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        console.error(chalk.red('\nError: Invalid source directory'));
+        console.error(chalk.dim(`Expected manifest at: ${sourceManifest}`));
+      }
+      process.exit(ExitCode.ERROR);
+    }
+  }
+
+  if (!sourceDir && options.repair) {
+    // Try to find source in common locations
+    const possibleSources = [
+      path.join(__dirname, '../../../../..'), // npm package root
+      path.join(projectRoot, 'node_modules/aios-core'),
+      path.join(projectRoot, 'node_modules/@synkra/aios-core'),
+    ];
+
+    for (const src of possibleSources) {
+      if (fs.existsSync(path.join(src, '.aios-core', 'install-manifest.yaml'))) {
+        sourceDir = src;
+        break;
+      }
+    }
+  }
+
+  // Show spinner for non-JSON output (must be defined before validator for closure)
+  let spinner = null;
+  if (!options.json) {
+    console.log('');
+    spinner = ora({
+      text: 'Loading installation manifest...',
+      color: 'cyan',
+    }).start();
+  }
+
+  // Create validator instance
+  const validator = new PostInstallValidator(projectRoot, sourceDir, {
+    verifyHashes: options.hash !== false,
+    detectExtras: options.extras === true,
+    verbose: options.verbose === true,
+    onProgress: options.json
+      ? () => {}
+      : (current, total, file) => {
+          if (spinner) {
+            spinner.text = `Validating ${current}/${total}: ${truncatePath(file, 40)}`;
+          }
+        },
+  });
+
+  try {
+    // Run validation
+    const report = await validator.validate();
+
+    if (spinner) {
+      spinner.succeed('Validation complete');
+    }
+
+    // Handle repair mode
+    let repairResult = null;
+    let repairAttempted = false;
+
+    if (options.repair && (report.stats.missingFiles > 0 || report.stats.corruptedFiles > 0)) {
+      repairAttempted = true;
+      if (!sourceDir) {
+        if (!options.json) {
+          console.error(chalk.yellow('\nWarning: Cannot repair - source directory not found'));
+          console.error(
+            chalk.dim('Specify source with --source <dir> or ensure package is installed')
+          );
+        }
+        repairResult = {
+          success: false,
+          error: 'Source directory not found',
+          repaired: [],
+          failed: [],
+        };
+      } else {
+        repairResult = await runRepair(validator, options, spinner);
+      }
+    }
+
+    // Output results
+    if (options.json) {
+      // Include repair results in JSON output for CI/CD pipelines
+      // SECURITY: Use explicit property copy to prevent prototype pollution
+      const output = {
+        status: report.status,
+        integrityScore: report.integrityScore,
+        manifestVerified: report.manifestVerified,
+        timestamp: report.timestamp,
+        duration: report.duration,
+        manifest: report.manifest,
+        stats: report.stats,
+        summary: report.summary,
+        recommendations: report.recommendations,
+        // Only include issues count in JSON to avoid leaking internal paths
+        issueCount: report.issues?.length ?? 0,
+        repair: repairAttempted
+          ? {
+              attempted: true,
+              success: repairResult?.success ?? false,
+              error: repairResult?.error ?? null,
+              dryRun: options.dryRun === true,
+              repairedCount: repairResult?.repaired?.length ?? 0,
+              failedCount: repairResult?.failed?.length ?? 0,
+              repaired: repairResult?.repaired ?? [],
+              failed: repairResult?.failed ?? [],
+            }
+          : { attempted: false },
+      };
+      console.log(JSON.stringify(output, null, 2));
+    } else {
+      console.log(formatReport(report, { colors: true, detailed: options.detailed }));
+
+      // Surface repair refusal errors in human-readable output
+      if (repairAttempted && !repairResult?.success && repairResult?.error) {
+        console.log('');
+        console.log(chalk.red(`Repair failed: ${repairResult.error}`));
+      }
+    }
+
+    // Exit with appropriate code
+    // If repair was attempted and successful (not dry-run), exit 0
+    // If repair failed or was not attempted and there are issues, exit 1
+    if (repairAttempted && !options.dryRun && repairResult?.success) {
+      // Repair succeeded - exit 0
+      process.exit(ExitCode.SUCCESS);
+    } else if (report.status === 'failed') {
+      process.exit(ExitCode.VALIDATION_FAILED);
+    } else if (
+      report.status === 'warning' &&
+      (report.stats.missingFiles > 0 || report.stats.corruptedFiles > 0)
+    ) {
+      process.exit(ExitCode.VALIDATION_FAILED);
+    } else {
+      process.exit(ExitCode.SUCCESS);
+    }
+  } catch (error) {
+    if (spinner) {
+      spinner.fail('Validation failed');
+    }
+
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            status: 'error',
+            error: error.message,
+            // SECURITY: Only include stack in verbose mode for debugging
+            stack: options.verbose ? error.stack : undefined,
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk.red(`\nError: ${error.message}`));
+      if (options.verbose) {
+        console.error(chalk.dim(error.stack));
+      }
+    }
+
+    process.exit(ExitCode.ERROR);
+  }
+}
+
+/**
+ * Run repair process
+ * @param {PostInstallValidator} validator - Validator instance
+ * @param {Object} options - Command options
+ * @param {Object} spinner - Ora spinner instance
+ * @returns {Object} Repair result with success status, repaired files, and failed files
+ */
+async function runRepair(validator, options, spinner) {
+  const dryRun = options.dryRun === true;
+
+  if (!options.json) {
+    console.log('');
+    if (dryRun) {
+      spinner = ora({
+        text: 'Analyzing files to repair (dry run)...',
+        color: 'yellow',
+      }).start();
+    } else {
+      spinner = ora({
+        text: 'Repairing files...',
+        color: 'green',
+      }).start();
+    }
+  }
+
+  const repairResult = await validator.repair({
+    dryRun,
+    onProgress: options.json
+      ? () => {}
+      : (current, total, file) => {
+          if (spinner) {
+            const action = dryRun ? 'Checking' : 'Repairing';
+            spinner.text = `${action} ${current}/${total}: ${truncatePath(file, 40)}`;
+          }
+        },
+  });
+
+  if (spinner) {
+    if (repairResult.success) {
+      const action = dryRun ? 'would be repaired' : 'repaired';
+      spinner.succeed(`${repairResult.repaired.length} file(s) ${action}`);
+    } else {
+      spinner.warn('Repair completed with some failures');
+    }
+  }
+
+  if (!options.json) {
+    // Show repair summary
+    if (repairResult.repaired.length > 0) {
+      console.log('');
+      console.log(chalk.bold(dryRun ? 'Files that would be repaired:' : 'Repaired files:'));
+      for (const file of repairResult.repaired.slice(0, 20)) {
+        const icon = dryRun ? chalk.yellow('○') : chalk.green('✓');
+        console.log(`  ${icon} ${file.path}`);
+      }
+      if (repairResult.repaired.length > 20) {
+        console.log(chalk.dim(`  ... and ${repairResult.repaired.length - 20} more`));
+      }
+    }
+
+    if (repairResult.failed.length > 0) {
+      console.log('');
+      console.log(chalk.bold(chalk.red('Failed to repair:')));
+      for (const file of repairResult.failed) {
+        console.log(`  ${chalk.red('✗')} ${file.path}: ${file.reason}`);
+      }
+    }
+  }
+
+  return repairResult;
+}
+
+/**
+ * Truncate path for display
+ * @param {string} filePath - File path
+ * @param {number} maxLen - Maximum length
+ * @returns {string} - Truncated path
+ */
+function truncatePath(filePath, maxLen) {
+  if (!filePath || filePath.length <= maxLen) return filePath;
+  return '...' + filePath.slice(-(maxLen - 3));
+}
+
+module.exports = {
+  createValidateCommand,
+};

package/.aios-core/constitution.md

@@ -0,0 +1,171 @@
+# Synkra AIOS Constitution
+
+> **Version:** 1.0.0 | **Ratified:** 2025-01-30 | **Last Amended:** 2025-01-30
+
+Este documento define os princípios fundamentais e inegociáveis do Synkra AIOS. Todos os agentes, tasks, e workflows DEVEM respeitar estes princípios. Violações são bloqueadas automaticamente via gates.
+
+---
+
+## Core Principles
+
+### I. CLI First (NON-NEGOTIABLE)
+
+O CLI é a fonte da verdade onde toda inteligência, execução, e automação vivem.
+
+**Regras:**
+- MUST: Toda funcionalidade nova DEVE funcionar 100% via CLI antes de qualquer UI
+- MUST: Dashboards apenas observam, NUNCA controlam ou tomam decisões
+- MUST: A UI NUNCA é requisito para operação do sistema
+- MUST: Ao decidir onde implementar, sempre CLI > Observability > UI
+
+**Hierarquia:**
+```
+CLI (Máxima) → Observability (Secundária) → UI (Terciária)
+```
+
+**Gate:** `dev-develop-story.md` - WARN se UI criada antes de CLI funcional
+
+---
+
+### II. Agent Authority (NON-NEGOTIABLE)
+
+Cada agente tem autoridades exclusivas que não podem ser violadas.
+
+**Regras:**
+- MUST: Apenas @devops pode executar `git push` para remote
+- MUST: Apenas @devops pode criar Pull Requests
+- MUST: Apenas @devops pode criar releases e tags
+- MUST: Agentes DEVEM delegar para o agente apropriado quando fora de seu escopo
+- MUST: Nenhum agente pode assumir autoridade de outro
+
+**Exclusividades:**
+
+| Autoridade | Agente Exclusivo |
+|------------|------------------|
+| git push | @devops |
+| PR creation | @devops |
+| Release/Tag | @devops |
+| Story creation | @sm, @po |
+| Architecture decisions | @architect |
+| Quality verdicts | @qa |
+
+**Gate:** Implementado via definição de agentes (não requer gate adicional)
+
+---
+
+### III. Story-Driven Development (MUST)
+
+Todo desenvolvimento começa e termina com uma story.
+
+**Regras:**
+- MUST: Nenhum código é escrito sem uma story associada
+- MUST: Stories DEVEM ter acceptance criteria claros antes de implementação
+- MUST: Progresso DEVE ser rastreado via checkboxes na story
+- MUST: File List DEVE ser mantida atualizada na story
+- SHOULD: Stories seguem o workflow: @po/@sm cria → @dev implementa → @qa valida → @devops push
+
+**Gate:** `dev-develop-story.md` - BLOCK se não houver story válida
+
+---
+
+### IV. No Invention (MUST)
+
+Especificações não inventam - apenas derivam dos requisitos.
+
+**Regras:**
+- MUST: Todo statement em spec.md DEVE rastrear para:
+  - Um requisito funcional (FR-*)
+  - Um requisito não-funcional (NFR-*)
+  - Uma constraint (CON-*)
+  - Um finding de research (verificado e documentado)
+- MUST NOT: Adicionar features não presentes nos requisitos
+- MUST NOT: Assumir detalhes de implementação não pesquisados
+- MUST NOT: Especificar tecnologias não validadas
+
+**Gate:** `spec-write-spec.md` - BLOCK se spec contiver invenções
+
+---
+
+### V. Quality First (MUST)
+
+Qualidade não é negociável. Todo código passa por múltiplos gates antes de merge.
+
+**Regras:**
+- MUST: `npm run lint` passa sem erros
+- MUST: `npm run typecheck` passa sem erros
+- MUST: `npm test` passa sem falhas
+- MUST: `npm run build` completa com sucesso
+- MUST: CodeRabbit não reporta issues CRITICAL
+- MUST: Story status é "Done" ou "Ready for Review"
+- SHOULD: Cobertura de testes não diminui
+
+**Gate:** `pre-push.md` - BLOCK se qualquer check falhar
+
+---
+
+### VI. Absolute Imports (SHOULD)
+
+Imports relativos criam acoplamento e dificultam refatoração.
+
+**Regras:**
+- SHOULD: Sempre usar imports absolutos com alias `@/`
+- SHOULD NOT: Usar imports relativos (`../../../`)
+- EXCEPTION: Imports dentro do mesmo módulo/feature podem ser relativos
+
+**Exemplo:**
+```typescript
+// CORRETO
+import { useStore } from '@/stores/feature/store'
+
+// INCORRETO
+import { useStore } from '../../../stores/feature/store'
+```
+
+**Gate:** ESLint rule (já implementado)
+
+---
+
+## Governance
+
+### Amendment Process
+
+1. Proposta de mudança documentada com justificativa
+2. Review por @architect e @po
+3. Aprovação requer consenso
+4. Mudança implementada com atualização de versão
+5. Propagação para templates e tasks dependentes
+
+### Versioning
+
+- **MAJOR:** Remoção ou redefinição incompatível de princípio
+- **MINOR:** Novo princípio ou expansão significativa
+- **PATCH:** Clarificações, correções de texto, refinamentos
+
+### Compliance
+
+- Todos os PRs DEVEM verificar compliance com Constitution
+- Gates automáticos BLOQUEIAM violações de princípios NON-NEGOTIABLE
+- Gates automáticos ALERTAM violações de princípios MUST
+- Violações de SHOULD são reportadas mas não bloqueiam
+
+### Gate Severity Levels
+
+| Severidade | Comportamento | Uso |
+|------------|---------------|-----|
+| BLOCK | Impede execução, requer correção | NON-NEGOTIABLE, MUST críticos |
+| WARN | Permite continuar com alerta | MUST não-críticos |
+| INFO | Apenas reporta | SHOULD |
+
+---
+
+## References
+
+- **Princípios derivados de:** `.claude/CLAUDE.md`
+- **Inspirado por:** GitHub Spec-Kit Constitution System
+- **Gates implementados em:** `.aios-core/development/tasks/`
+- **Checklists relacionados:** `.aios-core/product/checklists/`
+
+---
+
+*Synkra AIOS Constitution v1.0.0*
+*CLI First | Agent-Driven | Quality First*

package/.aios-core/core/config/config-loader.js

@@ -22,7 +22,7 @@
 
 const fs = require('fs').promises;
 const path = require('path');
-const yaml = require('yaml');
+const yaml = require('js-yaml');
 
 /**
  * Config cache with TTL
@@ -96,7 +96,7 @@ async function loadFullConfig() {
 
   try {
     const content = await fs.readFile(configPath, 'utf8');
-    const config = yaml.parse(content);
+    const config = yaml.load(content);
 
     const loadTime = Date.now() - startTime;
 

package/.aios-core/core/elicitation/elicitation-engine.js

@@ -19,7 +19,7 @@ const ElicitationSessionManager = require('./session-manager');
 let SecurityChecker = null;
 try {
   SecurityChecker = require('../../infrastructure/scripts/security-checker');
-} catch (e) {
+} catch (_e) {
   // Security checker not available - will use basic validation
   console.warn('[ElicitationEngine] SecurityChecker not found, using basic validation');
 }

package/.aios-core/core/elicitation/session-manager.js

@@ -138,7 +138,7 @@ class ElicitationSessionManager {
             progress: session.totalSteps > 0 ?
               Math.round((session.currentStep / session.totalSteps) * 100) : 0,
           });
-        } catch (error) {
+        } catch (_error) {
           // Skip invalid session files
           console.warn(`Invalid session file: ${file}`);
         }

package/.aios-core/core/elicitation/workflow-elicitation.js

@@ -4,6 +4,40 @@
  */
 
 const workflowElicitationSteps = [
+  {
+    title: 'Target Context',
+    description: 'Where should this workflow be created?',
+    help: 'Workflows can live in the AIOS core framework or within a specific squad.',
+    questions: [
+      {
+        type: 'list',
+        name: 'targetContext',
+        message: 'Where should this workflow be created?',
+        choices: [
+          { name: 'AIOS Core - Framework-level workflow', value: 'core' },
+          { name: 'Squad - Squad-specific workflow', value: 'squad' },
+          { name: 'Hybrid - Uses agents from both core AND a squad', value: 'hybrid' },
+        ],
+        default: 'core',
+      },
+      {
+        type: 'input',
+        name: 'squadName',
+        message: 'Which squad? (kebab-case name, e.g., "pedro-valerio"):',
+        when: (answers) => answers.targetContext === 'squad' || answers.targetContext === 'hybrid',
+        validate: (input) => {
+          if (!input) return 'Squad name is required';
+          if (!/^[a-z][a-z0-9-]*$/.test(input)) {
+            return 'Squad name must be kebab-case (lowercase with hyphens only)';
+          }
+          // Squad directory existence is validated at task execution time (pre-conditions)
+          return true;
+        },
+      },
+    ],
+    required: ['targetContext'],
+  },
+
   {
     title: 'Basic Workflow Information',
     description: 'Define the core details of your workflow',