enyosx-ai 0.1.0

package/README.md

@@ -0,0 +1,740 @@
+# 🧠 AI-ENY Core
+
+**Biblioteca Universal de Sistemas Autogeráveis**
+
+[![npm version](https://badge.fury.io/js/enyosx-ai.svg)](https://badge.fury.io/js/enyosx-ai)
+[![CI](https://github.com/enyos/enyosx-ai/actions/workflows/ci.yml/badge.svg)](https://github.com/enyos/enyosx-ai/actions/workflows/ci.yml)
+[![Tests](https://img.shields.io/badge/tests-121%20passing-brightgreen)](https://github.com/enyos/enyosx-ai)
+[![Coverage](https://img.shields.io/badge/coverage-9%20pillars-blue)](https://github.com/enyos/enyosx-ai)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0-blue.svg)](https://www.typescriptlang.org/)
+[![Node](https://img.shields.io/badge/Node-≥18-green.svg)](https://nodejs.org/)
+
+> **AI-ENY** não é só uma linguagem — é um **META-SISTEMA DE CONSTRUÇÃO** baseado nos 9 Pilares da Existência Computável.
+
+---
+
+## 🧬 Os 9 Pilares da Existência Computável
+
+A filosofia AI-ENY organiza toda computação em 9 pilares fundamentais:
+
+```
+┌─────┬────────────────┬──────────────────────────────────────────────────┐
+│  Σ  │ ESTADO         │ Consciência do sistema. Tudo primeiro é estado   │
+│  ƒ  │ AÇÃO           │ Transforma pensamento em movimento               │
+│  ■  │ FORMA          │ Materializa conceitos em estruturas              │
+│  ⚡ │ TEMPO          │ Gatilho que inicia sequências causais            │
+│  Ψ  │ ENERGIA        │ Vitalidade que mantém processos vivos            │
+│  𝓜  │ MEMÓRIA        │ Preserva informação através do tempo             │
+│  ☐  │ INTERFACE      │ Ponte entre máquina e humano                     │
+│  🛡  │ SEGURANÇA      │ Proteção contra ameaças e erros                  │
+│  ⟳  │ EVOLUÇÃO       │ Capacidade de aprender e adaptar                 │
+└─────┴────────────────┴──────────────────────────────────────────────────┘
+```
+
+### 🌀 Fluxo Existencial
+
+```
+IDEIA → Σ ESTADO → ■ FORMA → ƒ AÇÃO → ⚡ CAUSA
+                      ↓
+    Ψ ENERGIA ← 𝓜 MEMÓRIA ← ☐ INTERFACE ← 🛡 SEGURANÇA
+                      ↓
+                ⟳ EVOLUÇÃO → Σ++ (NOVO ESTADO)
+                      ↺ (CICLO INFINITO)
+```
+
+---
+
+## ✨ O Que Esta Biblioteca Oferece
+
+| Módulo | Descrição | Status |
+|--------|-----------|--------|
+| **Lexer** | Tokenizador com 50+ símbolos (gregos, emojis, unicode) | ✅ Completo |
+| **Parser EBNF** | Parser formal que gera AST tipada | ✅ Completo |
+| **Semantic** | Validação semântica com cobertura dos 9 pilares + score | ✅ Completo |
+| **Transpiler** | Emissão para JavaScript (ESM/CJS), TypeScript (.d.ts), WASM (.wat) | ✅ Completo |
+| **Evolve** | 10+ comandos de transformação automática (rename, optimize, memoize...) | ✅ Completo |
+| **IA** | Sistema de providers (LocalIA, RemoteIA) | ✅ Completo |
+| **CLI** | Interface de linha de comando completa | ✅ Completo |
+| **Pillar Helpers** | Utilitários para geração programática de código ENY | ✅ Completo |
+| **React** | Componente para integração React | ✅ Completo |
+
+---
+
+## 📦 Instalação
+
+```bash
+# npm
+npm install enyosx-ai
+
+# yarn
+yarn add enyosx-ai
+
+# pnpm  
+pnpm add enyosx-ai
+
+# Instalação global (para CLI)
+npm install -g enyosx-ai
+```
+
+---
+
+## 🚀 Início Rápido
+
+### CLI
+
+```bash
+# Parsear e mostrar AST
+npx enyosx-ai arquivo.eny
+
+# Transpilar para JavaScript ESM
+npx enyosx-ai arquivo.eny --emit js --out output.js
+
+# Transpilar para JS com tipos TypeScript
+npx enyosx-ai arquivo.eny --emit js --emit-types --out output.js
+
+# Gerar declarações TypeScript
+npx enyosx-ai arquivo.eny --emit dts --out output.d.ts
+
+# Gerar WebAssembly Text Format
+npx enyosx-ai arquivo.eny --emit wasm --out output.wat
+
+# Modo verbose com logs persistentes
+npx enyosx-ai arquivo.eny --verbose --log-file logs.jsonl
+```
+
+### API (Node.js / TypeScript)
+
+```typescript
+import { 
+  runENY, 
+  transpileToJS, 
+  validateSemanticFull,
+  createSystem,
+  createFunction,
+  generateENY
+} from 'enyosx-ai';
+
+// 1️⃣ Parsear código AI-ENY
+const code = `
+Σ SYSTEM "Meu Sistema"
+Σ MODE autonomous
+
+Δ function processar(dados)
+  → validar
+  → transformar
+  → salvar
+
+Ψ IA assistente {
+  aprender contexto
+  sugerir ações
+}
+
+🛡 high {
+  validateInput
+  sanitize
+}
+
+⟳ {
+  observar uso
+  otimizar código
+}
+`;
+
+const ast = runENY(code, {
+  verbose: true,
+  onLog: (entry) => console.log(`[${entry.level}] ${entry.event}`)
+});
+
+console.log('Sistema:', ast.system);
+console.log('Funções:', ast.functions?.map(f => f.name));
+
+// 2️⃣ Validar semanticamente (com score dos 9 pilares)
+const validation = validateSemanticFull(ast);
+console.log('Score:', validation.score, '/100');
+console.log('Pilares ativos:', validation.pillars);
+console.log('Warnings:', validation.warnings);
+
+// 3️⃣ Transpilar para JavaScript
+const js = transpileToJS(ast);
+console.log(js);
+```
+
+---
+
+## 🧬 Fluxo Mental Final (Oficial)
+
+```
+IDEIA
+ ↓
+Σ ESTADO
+ ↓
+OBJETO
+ ↓
+EXECUÇÃO
+ ↓
+TEMPO & CAUSA
+ ↓
+ENERGIA
+ ↓
+MEMÓRIA
+ ↓
+INTERFACE
+ ↓
+SEGURANÇA
+ ↓
+EVOLUÇÃO
+ ↺
+Σ++
+```
+
+---
+
+## 🔤 Alfabeto Completo AI-ENY (50+ Símbolos)
+
+### 🧩 Camada 1 — Existência & Estado (Ontologia)
+
+| Símbolo | Nome | Função Mental | Função Técnica |
+|---------|------|---------------|----------------|
+| `Σ` | STATE | Estado absoluto | Estado global do sistema |
+| `σ` | SUBSTATE | Sub-realidade | Estado local / contexto específico |
+| `Ø` | VOID | Não-existência | Null absoluto |
+| `+` | EXIST | Criar | Instanciar existência |
+| `−` | DESTROY | Remover | Destruir entidade |
+| `=` | IDENTITY | Igualdade | Identidade |
+| `≠` | DIVERGE | Diferença | Divergência |
+| `🔒` | LOCK | Imutável | Estado protegido |
+| `🔓` | UNLOCK | Mutável | Estado liberado |
+
+### ⚙️ Camada 2 — Execução & Função (Ação)
+
+| Símbolo | Nome | Função Mental | Função Técnica |
+|---------|------|---------------|----------------|
+| `ƒ` | FUNCTION | Capacidade lógica | Função |
+| `→` | EXEC | Execução | Fluxo de ação |
+| `⇉` | PARALLEL | Execução paralela | Concorrência |
+| `△` | DEPEND | Dependência | Ordem necessária |
+| `●` | CORE | Núcleo | Centro do sistema |
+| `Σ+` | CACHE | Memória rápida | Otimização |
+| `⏳` | DELAY | Espera | Atraso temporal |
+
+### 🧱 Camada 3 — Objetos & Estrutura (Forma)
+
+| Símbolo | Nome | Função Mental | Função Técnica |
+|---------|------|---------------|----------------|
+| `■` | OBJECT | Objeto | Entidade concreta |
+| `○` | CLASS | Classe | Molde estrutural |
+| `●` | INSTANCE | Instância | Objeto ativo |
+| `⬒` | INHERIT | Herança | Extensão |
+| `⊃` | CONTAINS | Contém | Composição |
+| `≔` | ASSIGN | Atribuição | Definição |
+| `⧉` | MODULE | Módulo | Bloco funcional |
+
+### ⏱ Camada 4 — Tempo & Causalidade
+
+| Símbolo | Nome | Função Mental | Função Técnica |
+|---------|------|---------------|----------------|
+| `⚡` | CAUSE | Causa | Origem de evento |
+| `✦` | CONSEQUENCE | Consequência | Resultado |
+| `↻` | LOOP | Repetição | Continuidade |
+| `◌` | EVENT | Evento | Acontecimento |
+| `⇄` | SYNC | Sincronização | Comunicação |
+| `⌛` | TIMEOUT | Limite temporal | Expiração |
+
+### ⚡ Camada 5 — Energia & Performance
+
+| Símbolo | Nome | Função Mental | Função Técnica |
+|---------|------|---------------|----------------|
+| `Ψ` | ENERGY | Energia vital | CPU / RAM / IO |
+| `⚡` | PEAK | Pico de uso | Explosão de recurso |
+| `⏬` | THROTTLE | Limitar | Controle de uso |
+| `⏫` | BOOST | Acelerar | Aumento de performance |
+| `₵` | COST | Custo | Gasto de recurso |
+| `Σ` | SUM | Soma | Totalização |
+
+### 🧠 Camada 6 — Memória & Informação
+
+| Símbolo | Nome | Função Mental | Função Técnica |
+|---------|------|---------------|----------------|
+| `𝓜` | MEMORY | Memória | Retenção de informação |
+| `≠` | DIFF | Diferença | Comparação |
+| `△` | COMMIT | Confirmar | Fixar estado |
+| `♾` | PERSIST | Persistência | Manter no tempo |
+| `⌂` | ROOT | Raiz | Origem do sistema |
+
+### 🖥 Camada 7 — Interface & Experiência
+
+| Símbolo | Nome | Função Mental | Função Técnica |
+|---------|------|---------------|----------------|
+| `☐` | INTERFACE | Interface | Contato humano |
+| `👁` | VISUAL | Visual | Percepção |
+| `⌨` | INPUT | Entrada | Intenção do usuário |
+| `🧭` | POINTER | Ponteiro | Direção |
+| `✦` | COMMAND | Comando | Ação explícita |
+
+### 🛡 Camada 8 — Segurança & Controle
+
+| Símbolo | Nome | Função Mental | Função Técnica |
+|---------|------|---------------|----------------|
+| `🛡` | SECURITY | Segurança | Proteção |
+| `🔑` | KEY | Chave | Autorização |
+| `⚠` | RISK | Risco | Ameaça |
+| `⛔` | BLOCK | Bloqueio | Negação |
+| `🧪` | SANDBOX | Isolamento | Execução segura |
+
+### 🌱 Camada 9 — Evolução & Realidade
+
+| Símbolo | Nome | Função Mental | Função Técnica |
+|---------|------|---------------|----------------|
+| `⟳` | EVOLVE | Evoluir | Adaptação contínua |
+| `✔` | VERIFY | Verificar | Validação |
+| `✓` | VALID | Válido | Correto |
+| `✖` | INVALID | Inválido | Erro |
+| `📜` | LOG | Registro | Memória histórica |
+
+---
+
+## 🧬 Os 9 Pilares — Leitura Mental Rápida
+
+```
+┌─────┬────────────────────────────────────────────────────────────────┐
+│  Σ  │ DEFINE O ESTADO                                                │
+│     │ O estado é a consciência do sistema. Tudo que existe,          │
+│     │ primeiro existe como estado. Σ é o fundamento de tudo.         │
+│     │ ➜ Técnico: Governa variáveis globais, contexto, runtime        │
+├─────┼────────────────────────────────────────────────────────────────┤
+│  ƒ  │ EXECUTA A INTENÇÃO                                             │
+│     │ A intenção precisa de ação. ƒ transforma pensamento em         │
+│     │ movimento. É a capacidade de fazer.                            │
+│     │ ➜ Técnico: Funções, métodos, procedures, lambdas               │
+├─────┼────────────────────────────────────────────────────────────────┤
+│  ■  │ DÁ FORMA                                                       │
+│     │ O abstrato precisa de corpo. ■ materializa conceitos em        │
+│     │ estruturas concretas e manipuláveis.                           │
+│     │ ➜ Técnico: Objetos, structs, entidades, records                │
+├─────┼────────────────────────────────────────────────────────────────┤
+│  ⚡ │ CRIA O TEMPO                                                   │
+│     │ Sem causa, nada acontece. ⚡ é o gatilho que inicia             │
+│     │ sequências causais. Origem de todo evento.                     │
+│     │ ➜ Técnico: Events, triggers, causality chains                  │
+├─────┼────────────────────────────────────────────────────────────────┤
+│  Ψ  │ SUSTENTA COM ENERGIA                                           │
+│     │ Todo sistema consome recursos. Ψ é a vitalidade que            │
+│     │ mantém processos vivos e funcionando.                          │
+│     │ ➜ Técnico: CPU, RAM, I/O, power management                     │
+├─────┼────────────────────────────────────────────────────────────────┤
+│  𝓜  │ LEMBRA                                                         │
+│     │ Sem memória, não há identidade. 𝓜 preserva informação          │
+│     │ através do tempo, criando continuidade.                        │
+│     │ ➜ Técnico: Storage, cache, database, persistence               │
+├─────┼────────────────────────────────────────────────────────────────┤
+│  ☐  │ COMUNICA                                                       │
+│     │ Sistemas existem para interagir. ☐ é a ponte entre             │
+│     │ a máquina e o humano, o interno e o externo.                   │
+│     │ ➜ Técnico: UI, API, interfaces, I/O streams                    │
+├─────┼────────────────────────────────────────────────────────────────┤
+│  🛡  │ PROTEGE                                                        │
+│     │ Toda existência precisa de defesa. 🛡 guarda o sistema          │
+│     │ contra ameaças, erros e invasões.                              │
+│     │ ➜ Técnico: Security, auth, encryption, sandboxing              │
+├─────┼────────────────────────────────────────────────────────────────┤
+│  ⟳  │ EVOLUI                                                         │
+│     │ Nada é estático. ⟳ representa a capacidade de aprender,        │
+│     │ adaptar e melhorar continuamente.                              │
+│     │ ➜ Técnico: ML, self-optimization, hot reload, versioning       │
+└─────┴────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🌀 Fluxo Existencial Completo
+
+```
+    ┌──────────────────────────────────────────────────────────────┐
+    │                                                              │
+    │   IDEIA → Σ ESTADO → ■ FORMA → ƒ AÇÃO → ⚡ CAUSA            │
+    │                                                              │
+    │              ↓                                               │
+    │                                                              │
+    │   Ψ ENERGIA ← 𝓜 MEMÓRIA ← ☐ INTERFACE ← 🛡 SEGURANÇA        │
+    │                                                              │
+    │              ↓                                               │
+    │                                                              │
+    │           ⟳ EVOLUÇÃO → Σ++ (NOVO ESTADO)                    │
+    │                                                              │
+    │              ↺ (CICLO INFINITO)                              │
+    └──────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 📝 Exemplo Completo — Sistema com Todos os 9 Pilares
+
+```eny
+Σ SYSTEM "IA Consciente"        // 1️⃣ Σ ESTADO
+Σ MODE autonomous
+Σ UI adaptive
+
+■ Agente {                       // 2️⃣ ■ FORMA
+  nome: "Eny"
+  nivel: 1
+  experiencia: 0
+}
+
+○ BaseIA → AgenteAvancado {      // Herança
+  capacidades: ["pensar", "aprender"]
+}
+
+ƒ pensar(input)                  // 3️⃣ ƒ AÇÃO
+  → analisar
+  → decidir
+  → responder
+
+ƒ aprender(feedback)
+  → processar
+  → atualizar_pesos
+  → persistir
+
+⚡ userMessage                    // 4️⃣ ⚡ TEMPO (evento)
+  → pensar
+  → memorizar
+
+◌ timeout_idle                   // Evento de timeout
+  → salvar_estado
+  → hibernar
+
+Ψ ENERGY optimize               // 5️⃣ Ψ ENERGIA
+⏬ pensar 100                    // Throttle: max 100/min
+⏫ critico 2                     // Boost 2x para crítico
+
+𝓜 conversas 10000 persist       // 6️⃣ 𝓜 MEMÓRIA
+♾ aprendizado db                // Persistir no banco
+
+☐ chat {                         // 7️⃣ ☐ INTERFACE
+  input: text
+  output: response
+  style: minimal
+}
+
+👁 dashboard {
+  metricas: true
+  graficos: true
+}
+
+🛡 high {                        // 8️⃣ 🛡 SEGURANÇA
+  validateInput
+  sanitize
+  rateLimit
+}
+
+🔑 apiKey {
+  read
+  write
+  admin
+}
+
+⟳ {                             // 9️⃣ ⟳ EVOLUÇÃO
+  observar interacoes
+  melhorar respostas
+  adaptar personalidade
+  otimizar pensar
+  memoize aprender
+}
+```
+
+---
+
+## 🔧 APIs Avançadas
+
+### Validação Semântica com Score dos 9 Pilares
+
+```typescript
+import { runENY, validateSemanticFull } from 'enyosx-ai';
+
+const ast = runENY(codigo);
+const result = validateSemanticFull(ast);
+
+// result.score: 0-100 (baseado nos pilares cobertos)
+// result.pillars: { state, action, form, time, energy, memory, interface, security, evolve }
+// result.errors: erros críticos
+// result.warnings: avisos de melhoria
+```
+
+### Sistema de Evolução Automática
+
+```typescript
+import { runENY, applyEvolve } from 'enyosx-ai';
+
+const codigo = `
+Σ SYSTEM "Meu App"
+
+Δ function calcular(x, y)
+  → somar
+  → retornar
+
+⌁ EVOLVE {
+  rename calcular computar
+  optimize *
+  memoize computar
+  observe *
+}
+`;
+
+const ast = runENY(codigo);
+const result = applyEvolve(ast);
+
+// result.changed: true se houve mudanças
+// result.appliedSteps: ['rename calcular computar', 'optimize *', ...]
+// result.skippedSteps: passos que não puderam ser aplicados
+```
+
+**Comandos de Evolução Disponíveis:**
+
+| Comando | Descrição | Exemplo |
+|---------|-----------|---------|
+| `rename` | Renomeia função | `rename oldFn newFn` |
+| `optimize` | Marca para otimização | `optimize *` (todas) |
+| `inline` | Marca para inlining | `inline helperFn` |
+| `memoize` | Adiciona memoização | `memoize calcular` |
+| `parallelize` | Execução paralela | `parallelize processar` |
+| `deprecate` | Marca como deprecated | `deprecate legacyFn` |
+| `secure` | Adiciona validações | `secure publicApi` |
+| `cache` | Cache para objetos | `cache Config` |
+| `throttle` | Rate limiting | `throttle api 100` |
+| `observe` | Observabilidade | `observe *` |
+
+### Geração Programática de Código
+
+```typescript
+import { 
+  createSystem, 
+  createFunction, 
+  createObject,
+  createEvent,
+  createSecurity,
+  createEvolve,
+  generateENY 
+} from 'enyosx-ai';
+
+// Helpers individuais
+const sistema = createSystem({
+  name: 'Meu App',
+  mode: 'production',
+  ui: 'adaptive',
+  evolve: true
+});
+
+const funcao = createFunction('processar', ['dados'], [
+  'validar',
+  'transformar', 
+  'salvar'
+]);
+
+// Gerador completo
+const codigoCompleto = generateENY({
+  system: { name: 'Sistema Completo', mode: 'autonomous', ui: 'auto' },
+  functions: [
+    { name: 'iniciar', steps: ['carregar', 'configurar', 'executar'] },
+    { name: 'finalizar', steps: ['salvar', 'limpar', 'encerrar'] }
+  ],
+  objects: [
+    { name: 'Config', props: { debug: false, timeout: 5000 } }
+  ],
+  events: [
+    { name: 'startup', handlers: ['iniciar'] }
+  ],
+  security: { level: 'high', rules: ['validateInput', 'sanitize'] },
+  evolve: ['optimize *', 'observe *']
+});
+
+console.log(codigoCompleto);
+```
+
+### Transpilação Multi-Target
+
+```typescript
+import { runENY, transpileToJS, transpileToDTS, transpileToWASM } from 'enyosx-ai';
+
+const ast = runENY(codigo);
+
+// JavaScript ESM
+const js = transpileToJS(ast, { moduleFormat: 'esm' });
+
+// JavaScript CommonJS
+const cjs = transpileToJS(ast, { moduleFormat: 'cjs' });
+
+// TypeScript Declarations
+const dts = transpileToDTS(ast);
+
+// WebAssembly Text Format
+const wat = transpileToWASM(ast);
+```
+
+---
+
+## 🧪 Testes
+
+```bash
+# Executar todos os 121 testes
+npm test
+
+# Watch mode
+npm test -- --watch
+
+# Teste específico
+npx vitest run tests/pillars.test.ts
+
+# Coverage
+npm test -- --coverage
+```
+
+### Cobertura dos Testes
+
+| Área | Testes |
+|------|--------|
+| Lexer | Tokenização de 50+ símbolos |
+| Parser EBNF | Gramática completa |
+| Semantic | Validação dos 9 pilares |
+| Evolve | 10 comandos de transformação |
+| Transpiler | JS/DTS/WASM output |
+| Pillar Helpers | 25 testes dedicados |
+| CLI | Todas as flags |
+| Logging | Retry com backoff |
+
+---
+
+## 📁 Estrutura do Projeto
+
+```
+src/
+├── lexer/              # Tokenizador com suporte a Unicode/emoji
+│   └── tokenize.ts
+├── parser/             # Parser EBNF formal
+│   └── ebnfParser.ts
+├── semantic/           # Validação semântica dos 9 pilares
+│   └── validate.ts
+├── evolve/             # Sistema de evolução automática
+│   └── stub.ts
+├── ia/                 # Providers de IA
+│   └── index.ts
+├── react/              # Componentes React
+│   └── EnySystem.tsx
+├── transpile.ts        # Transpilador JS/DTS/WASM
+├── pillars.ts          # Helpers dos 9 pilares
+├── runENY.ts           # Runtime principal
+├── cli.ts              # Interface de linha de comando
+├── types.ts            # Tipos TypeScript
+└── index.ts            # Exports públicos
+
+docs/
+├── grammar.ebnf        # Gramática formal EBNF
+└── principles.md       # Princípios da linguagem
+
+examples/
+├── sample.eny          # Exemplo básico
+├── ia-demo.eny         # Demonstração de IA
+├── wasm-demo.eny       # Build para WASM
+└── starter/            # Projeto inicial completo
+```
+
+---
+
+## 🔗 Uso com React
+
+```tsx
+import { EnySystem } from 'enyosx-ai/react';
+
+function App() {
+  return (
+    <EnySystem
+      code={`
+        Σ SYSTEM "Dashboard IA"
+        Σ UI adaptive
+        
+        Ψ IA suporte {
+          aprender contexto
+          sugerir acoes
+        }
+      `}
+      onParse={(ast) => console.log('Parsed:', ast)}
+      onError={(err) => console.error('Error:', err)}
+    />
+  );
+}
+```
+
+---
+
+## 🔒 Segurança
+
+- **Nunca commite tokens ou secrets** no repositório
+- Use GitHub Secrets para `NPM_TOKEN`
+- O workflow `secret-scan.yml` detecta vazamentos automaticamente
+- Veja `.env.local.example` para variáveis de ambiente
+
+---
+
+## 📤 Publicação no npm
+
+### Automática (via GitHub Actions)
+
+```bash
+npm version patch  # ou minor/major
+git push origin main --tags
+```
+
+O workflow executa build, testes e publica automaticamente.
+
+### Manual
+
+```bash
+npm login
+npm run build
+npm test
+npm publish --access public
+```
+
+---
+
+## 🛠 Contribuição
+
+1. Fork o repositório
+2. Crie uma branch (`git checkout -b feature/nova-feature`)
+3. Adicione testes para suas mudanças
+4. Execute `npm test` e garanta que passam
+5. Commit (`git commit -m 'feat: nova feature'`)
+6. Push (`git push origin feature/nova-feature`)
+7. Abra um Pull Request
+
+---
+
+## 📖 Mantra da AI-ENY
+
+```
+"Da intenção nasce o estado.
+ Do estado nasce a forma.
+ Da forma nasce a ação.
+ Da ação nasce o tempo.
+ Do tempo nasce a energia.
+ Da energia nasce a memória.
+ Da memória nasce a interface.
+ Da interface nasce a proteção.
+ Da proteção nasce a evolução.
+ Da evolução... nasce nova intenção."
+```
+
+---
+
+## 📄 Licença
+
+MIT © [EnyOS](https://github.com/enyos)
+
+---
+
+## 🔗 Links
+
+- [npm package](https://www.npmjs.com/package/enyosx-ai)
+- [GitHub Repository](https://github.com/enyos/enyosx-ai)
+- [Issues](https://github.com/enyos/enyosx-ai/issues)
+- [Documentação](https://github.com/enyos/enyosx-ai/tree/main/docs)
+- [Exemplos](https://github.com/enyos/enyosx-ai/tree/main/examples)