🔬 AIOS-Core Deep Dive

Análise técnica detalhada dos módulos internos

📜 Constitution - Princípios Fundamentais

A Constitution define os princípios inegociáveis do AIOS. Violações são bloqueadas automaticamente via gates.

NON-NEGOTIABLE I. CLI First

O CLI é a fonte da verdade onde toda inteligência, execução e automação vivem.

  • Toda funcionalidade nova DEVE funcionar 100% via CLI antes de qualquer UI
  • Dashboards apenas observam, NUNCA controlam ou tomam decisões
  • A UI NUNCA é requisito para operação do sistema
Hierarquia: CLI (Máxima) → Observability (Secundária) → UI (Terciária)

NON-NEGOTIABLE II. Agent Authority

Cada agente tem autoridades exclusivas que não podem ser violadas.

AutoridadeAgente Exclusivo
git push@devops
PR creation@devops
Release/Tag@devops
Story creation@sm, @po
Architecture decisions@architect
Quality verdicts@qa

MUST III. Story-Driven Development

Todo desenvolvimento começa e termina com uma story.

  • Nenhum código é escrito sem uma story associada
  • Stories DEVEM ter acceptance criteria claros
  • Progresso rastreado via checkboxes

MUST IV. No Invention

Especificações não inventam - apenas derivam dos requisitos.

  • Todo statement em spec.md DEVE rastrear para FR-*, NFR-*, CON-* ou findings
  • NUNCA adicionar features não presentes nos requisitos
  • NUNCA especificar tecnologias não validadas

MUST V. Quality First

Qualidade não é negociável. Todo código passa por múltiplos gates antes de merge.

npm run lint ✓
npm run typecheck ✓
npm test ✓
npm run build ✓
CodeRabbit: no CRITICAL issues
Story status: Done/Ready for Review

SHOULD VI. Absolute Imports

Imports relativos criam acoplamento e dificultam refatoração.

// CORRETO
import { useStore } from '@/stores/feature/store'

// INCORRETO
import { useStore } from '../../../stores/feature/store'

Gate Severity Levels

SeveridadeComportamentoUso
BLOCKImpede execuçãoNON-NEGOTIABLE, MUST críticos
WARNPermite com alertaMUST não-críticos
INFOApenas reportaSHOULD

🎭 Master Orchestrator (1542 LOC)

Central orchestrator que conecta todos os epics ADE (3→4→5→6) em um pipeline unificado de execução.

State Machine (AC6)

INITIALIZED → READY → IN_PROGRESS → COMPLETE
                    ↓           ↓
                 BLOCKED ←──────┘
StateDescrição
INITIALIZEDApós construção
READYPronto após pre-flight checks
IN_PROGRESSExecutando epics
BLOCKEDErro ou intervenção necessária
COMPLETETodos epics concluídos

Epic Configuration

EpicNomeExecutorOn-Demand
3Spec PipelineEpic3Executor
4Execution EngineEpic4Executor
5Recovery SystemEpic5Executor
6QA LoopEpic6Executor

Context Building por Epic

  • Epic 3 (Spec): source, prdPath
  • Epic 4 (Execution): spec path, complexity, requirements
  • Epic 5 (Recovery): implementationPath, errors, attempts
  • Epic 6 (QA): buildResult, testResults, codeChanges
  • Epic 7 (Memory): qaReport, patterns, sessionInsights

Integrations

  • TechStackDetector - Pre-flight detection (AC7)
  • RecoveryHandler - Story 0.5
  • GateEvaluator - Story 0.6
  • AgentInvoker - Story 0.7
  • DashboardIntegration - Story 0.8

🔍 Stuck Detector (1249 LOC)

Detecta quando execução está stuck em padrões circulares ou falhas repetidas.

Acceptance Criteria

  • AC1: Detecta stuck: 3+ falhas consecutivas
  • AC2: Detecta circular: abordagem similar à que já falhou
  • AC3: Bloqueia execução se circular detectado
  • AC4: Marca subtask como "stuck" em implementation.yaml
  • AC5: Escala para humano com contexto completo
  • AC6: Sugere abordagens alternativas baseadas nos erros
  • AC7: Configurável via autoClaude.recovery.maxAttempts

Error Pattern Categories

dependency

cannot find module, module not found, import failed

type

type error, typescript error, is not assignable

config

configuration error, missing config, env undefined

test

test failed, assertion failed, timeout exceeded

syntax

syntax error, unexpected token, parsing error

network

network error, ECONNREFUSED, fetch failed

Circular Detection Algorithm

function check(attempts, currentApproach):
    recentAttempts = attempts.slice(-windowSize)
    consecutiveFailures = countConsecutive(recentAttempts)
    
    if consecutiveFailures >= maxAttempts:
        return { stuck: true, reason: 'consecutive_failures' }
    
    if circularDetection && currentApproach:
        similarity = compareApproaches(currentApproach, failedApproaches)
        if similarity >= similarityThreshold:
            return { stuck: true, reason: 'circular_approach' }

💾 Build State Manager (1529 LOC)

Gerencia estado de builds autônomos, permitindo resume de checkpoints após falhas.

Build Status Enum

StatusDescrição
PENDINGAguardando início
IN_PROGRESSEm execução
PAUSEDPausado pelo usuário
ABANDONED> 1 hora sem atividade
FAILEDFalhou após max retries
COMPLETEDConcluído com sucesso

State Schema (AC1)

{
  storyId: string,
  startedAt: ISO8601,
  lastCheckpoint: ISO8601,
  status: BuildStatus,
  currentPhase: string,
  currentSubtask: string,
  completedSubtasks: [],
  failedAttempts: [],
  worktree: string | null,
  checkpoints: [],
  metrics: {
    totalSubtasks: number,
    completedSubtasks: number,
    totalAttempts: number,
    averageTimePerSubtask: number
  }
}

Epic 5 Integration (AC8)

  • StuckDetector - Detecta builds stuck
  • RecoveryTracker - Rastreia tentativas de recuperação

🔀 Semantic Merge Engine (1735 LOC)

Sistema de merge semântico alimentado por AI para resolver conflitos entre trabalho paralelo de agentes.

Arquitetura

  1. SemanticAnalyzer - Extrai elementos semânticos do código
  2. ConflictDetector - Detecta conflitos usando regras de compatibilidade
  3. AutoMerger - Resolve conflitos simples deterministicamente
  4. AIResolver - Usa Claude para conflitos complexos
  5. MergeOrchestrator - Coordena o pipeline completo

Change Types

IMPORT

added, removed, modified

FUNCTION

added, removed, modified

CLASS

added, removed, modified

VARIABLE

added, removed, modified

Merge Strategies

StrategyQuando usar
COMBINEMudanças podem coexistir
TAKE_NEWERPegar mudança mais recente
TAKE_LARGERPegar mudança mais abrangente
AI_REQUIREDPrecisa AI para resolver
HUMAN_REQUIREDMuito complexo, precisa humano

Compatibility Rules

// Combinações compatíveis (auto-merge)
IMPORT_ADDED + IMPORT_ADDED → COMBINE
FUNCTION_ADDED + FUNCTION_ADDED → COMBINE
FUNCTION_ADDED + IMPORT_ADDED → COMBINE

// Conflitos (AI required)
FUNCTION_MODIFIED + FUNCTION_MODIFIED → AI_REQUIRED

🔎 Pattern Extractor (1561 LOC)

Analisa código via AST e regex para detectar padrões comuns, gerando patterns.md para referência.

Pattern Categories

  • STATE_MANAGEMENT - Zustand, Redux, MobX, Vuex, Pinia, Context API
  • API_CALLS - fetch-wrapper, axios, react-query, SWR, tRPC, GraphQL
  • ERROR_HANDLING - try-catch-toast, error-boundary, global-handler
  • COMPONENTS - React patterns
  • DATA_ACCESS - Database patterns
  • TESTING - Jest, Vitest, RTL, Cypress, Playwright
  • HOOKS - Custom hooks
  • UTILITIES - Helper functions

Output Example

{
  category: "State Management",
  name: "Zustand Store with Persist",
  description: "State management with persistence...",
  whenToUse: "Any domain state that needs persistence...",
  example: "```typescript\nimport { create } from 'zustand'...",
  filesUsing: ["src/stores/userStore.ts"],
  confidence: 0.95
}

🗺️ Codebase Mapper (1286 LOC)

Gera mapas abrangentes do codebase para geração de contexto. Usado pelo Context Generator (Epic 4).

Output: .aios/codebase-map.json

  • services - Serviços detectados
  • directories - Estrutura de diretórios
  • patterns - Padrões encontrados
  • conventions - Convenções do projeto
  • dependencies - Runtime e dev dependencies

Pattern Detectors

CategoriaPatterns
State Managementzustand, redux, mobx, vuex, pinia, context-api
API Patternsfetch-wrapper, axios, react-query, swr, trpc, graphql
Testingjest, vitest, react-testing-library, cypress, playwright
Error Handlingtry-catch-toast, error-boundary, global-error-handler

Config Files Detectados

package.json, tsconfig.json, vite.config.*, next.config.*, webpack.config.js, .eslintrc*, jest.config.*, vitest.config.*, docker-compose.yml, Dockerfile, pyproject.toml, Cargo.toml, go.mod, Gemfile...

⚡ Performance Optimizer (1901 LOC)

Analisa código para bottlenecks e sugere otimizações de runtime, memória e escalabilidade.

Optimization Patterns

HIGH Algorithm Complexity

Otimiza algoritmos com alta complexidade de tempo

HIGH Loop Optimization

Otimiza loops aninhados e iterações ineficientes

MEDIUM Memory Usage

Reduz consumo de memória e previne leaks

HIGH Async Operations

Otimiza async/await e uso de Promises

MEDIUM Caching

Identifica oportunidades de memoization

HIGH Database Queries

Otimiza queries e reduz N+1 problems

MEDIUM Bundle Size

Reduz tamanho de bundles JavaScript

MEDIUM React Performance

Otimiza rendering de componentes React

Static Analysis Metrics

{
  complexity: number,      // Cyclomatic complexity
  functionCount: number,
  loopDepth: number,       // Max nested loop depth
  asyncOperations: number,
  stringOperations: number,
  objectOperations: number,
  arrayOperations: number,
  domOperations: number,
  fileSize: number,
  lineCount: number
}