enyosx-ai

v0.1.0

Published

19 days ago

AI-ENY Core — Biblioteca da linguagem EnyOS (projeto experimental)

Downloads

117

0High
0Medium
0Low

gustavomartinseny

enyosx-ai eny ai-eny language compiler meta-system

🧠 AI-ENY Core

Biblioteca Universal de Sistemas Autogeráveis

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

# 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

# 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)

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

Σ 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

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

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

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

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

# 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

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)

npm version patch  # ou minor/major
git push origin main --tags

O workflow executa build, testes e publica automaticamente.

Manual

npm login
npm run build
npm test
npm publish --access public

🛠 Contribuição

Fork o repositório
Crie uma branch (git checkout -b feature/nova-feature)
Adicione testes para suas mudanças
Execute npm test e garanta que passam
Commit (git commit -m 'feat: nova feature')
Push (git push origin feature/nova-feature)
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