eny-ai 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,704 @@
+export { ALPHABET, FALSE, NIL, SYMBOLS, TRANSPILE_MAP, TRUE, VOID, asyncFn, component, effect, error, filter, find, fn, get, log, map, navigate, post, reduce, shape, state, storageGet, storageSet, toSymbolic, transpileSymbols, validate } from './symbols.cjs';
+
+type Step = {
+    raw: string;
+};
+type FunctionNode = {
+    type: 'function';
+    name: string;
+    args?: string[];
+    steps: Step[];
+    optimized?: boolean;
+};
+type IANode = {
+    type: 'ia';
+    name: string;
+    body: string[];
+};
+type ModuleNode = {
+    type: 'module';
+    name: string;
+};
+type ObjectNode = {
+    type: 'object';
+    name: string;
+    props: Record<string, string | null>;
+};
+type FormNode = {
+    type: 'form';
+    name: string;
+    props: Record<string, any>;
+};
+type AnimationNode = {
+    type: 'animation';
+    name: string;
+    props: Record<string, any>;
+};
+type LogicNode = {
+    type: 'logic';
+    rule: string;
+    trueFlow?: string[];
+    falseFlow?: string[];
+};
+type ParallelNode = {
+    type: 'parallel';
+    items: string[];
+};
+type BuildNode = {
+    type: 'build';
+    targets: string[];
+};
+type EvolveNode = {
+    type: 'evolve';
+    steps: string[];
+};
+/** σ SUBSTATE - Estado local/contexto específico */
+type SubstateNode = {
+    type: 'substate';
+    name: string;
+    parent?: string;
+    props: Record<string, any>;
+};
+/** ○ CLASS - Classe/molde estrutural */
+type ClassNode = {
+    type: 'class';
+    name: string;
+    extends?: string;
+    props: Record<string, any>;
+    methods?: string[];
+};
+/** ↻ LOOP - Repetição/continuidade */
+type LoopNode = {
+    type: 'loop';
+    name?: string;
+    condition?: string;
+    count?: number;
+    body: string[];
+};
+/** ◌ EVENT - Evento/acontecimento */
+type EventNode = {
+    type: 'event';
+    name: string;
+    trigger?: string;
+    handler?: string[];
+};
+/** ⇄ SYNC - Sincronização/comunicação */
+type SyncNode = {
+    type: 'sync';
+    sources: string[];
+    target?: string;
+};
+/** ⌛ TIMEOUT - Limite temporal */
+type TimeoutNode = {
+    type: 'timeout';
+    duration: number;
+    unit?: 'ms' | 's' | 'm';
+    action?: string;
+};
+/** ⏳ DELAY - Espera/atraso temporal */
+type DelayNode = {
+    type: 'delay';
+    duration: number;
+    unit?: 'ms' | 's' | 'm';
+};
+/** 🛡 SECURITY - Segurança/proteção */
+type SecurityNode = {
+    type: 'security';
+    level?: 'low' | 'medium' | 'high' | 'critical';
+    rules: string[];
+};
+/** 🔑 KEY - Chave/autorização */
+type KeyNode = {
+    type: 'key';
+    name: string;
+    scope?: string;
+    permissions?: string[];
+};
+/** 🧪 SANDBOX - Isolamento/execução segura */
+type SandboxNode = {
+    type: 'sandbox';
+    name: string;
+    restrictions?: string[];
+    body: string[];
+};
+/** ⚡ CAUSE - Causa/origem de evento */
+type CauseNode = {
+    type: 'cause';
+    trigger: string;
+    effects: string[];
+};
+/** ✦ CONSEQUENCE - Consequência/resultado */
+type ConsequenceNode = {
+    type: 'consequence';
+    source: string;
+    result: string;
+};
+/** 𝓜 MEMORY - Memória/retenção de informação */
+type MemoryNode = {
+    type: 'memory';
+    name: string;
+    size?: number;
+    persist?: boolean;
+};
+/** ♾ PERSIST - Persistência */
+type PersistNode = {
+    type: 'persist';
+    target: string;
+    storage?: 'local' | 'session' | 'db' | 'file';
+};
+/** ⌂ ROOT - Raiz do sistema */
+type RootNode = {
+    type: 'root';
+    name: string;
+    children?: string[];
+};
+/** ☐ INTERFACE - Interface/contato humano */
+type InterfaceNode = {
+    type: 'interface';
+    name: string;
+    methods: string[];
+};
+/** 👁 VISUAL - Visual/percepção */
+type VisualNode = {
+    type: 'visual';
+    name: string;
+    props: Record<string, any>;
+};
+/** ⌨ INPUT - Entrada/intenção do usuário */
+type InputNode = {
+    type: 'input';
+    name: string;
+    inputType?: 'text' | 'number' | 'file' | 'event';
+    handler?: string;
+};
+/** ⏬ THROTTLE - Limitar/controle de uso */
+type ThrottleNode = {
+    type: 'throttle';
+    target: string;
+    limit: number;
+    window?: number;
+};
+/** ⏫ BOOST - Acelerar/aumento de performance */
+type BoostNode = {
+    type: 'boost';
+    target: string;
+    factor?: number;
+};
+/** ₵ COST - Custo/gasto de recurso */
+type CostNode = {
+    type: 'cost';
+    operation: string;
+    value: number;
+    unit?: string;
+};
+/** 🔒 LOCK - Imutável/estado protegido */
+type LockNode = {
+    type: 'lock';
+    target: string;
+    reason?: string;
+};
+/** 🔓 UNLOCK - Mutável/estado liberado */
+type UnlockNode = {
+    type: 'unlock';
+    target: string;
+};
+/** Ø VOID - Não-existência/null absoluto */
+type VoidNode = {
+    type: 'void';
+    target?: string;
+};
+/** ⬒ INHERIT - Herança/extensão */
+type InheritNode = {
+    type: 'inherit';
+    child: string;
+    parent: string;
+};
+/** ⊃ CONTAINS - Contém/composição */
+type ContainsNode = {
+    type: 'contains';
+    container: string;
+    items: string[];
+};
+/** ✔ VERIFY - Verificar/validação */
+type VerifyNode = {
+    type: 'verify';
+    target: string;
+    rules?: string[];
+};
+/** 📜 LOG - Registro/memória histórica */
+type LogNode = {
+    type: 'log';
+    message: string;
+    level?: 'debug' | 'info' | 'warn' | 'error';
+};
+/** Σ KERNEL - Conexão com kernel/sistema */
+type KernelNode = {
+    type: 'kernel';
+    hooks: string[];
+};
+/** Σ DATABASE - Banco de dados auto-gerenciado */
+type DatabaseNode = {
+    type: 'database';
+    mode: 'auto' | 'manual' | 'hybrid';
+    provider?: string;
+};
+/** Σ TRAINING - Modo treino/gamificado */
+type TrainingNode = {
+    type: 'training';
+    topic: string;
+    level?: number;
+};
+type LogEntry = {
+    timestamp: string;
+    level: 'info' | 'debug' | 'warn' | 'error';
+    event: string;
+    i?: number;
+    line?: string;
+    detail?: any;
+};
+type ParseOptions = {
+    verbose?: boolean;
+    onLog?: (entry: LogEntry) => void;
+    logFile?: string;
+    logRetryAttempts?: number;
+    logRetryDelayMs?: number;
+};
+type EnyAST = {
+    system?: string | null;
+    version?: string | null;
+    mode?: string | null;
+    targets?: string[];
+    ui?: string | null;
+    database?: DatabaseNode | null;
+    kernel?: KernelNode | null;
+    training?: TrainingNode | null;
+    modules?: ModuleNode[];
+    functions?: FunctionNode[];
+    ias?: IANode[];
+    objects?: ObjectNode[];
+    forms?: FormNode[];
+    animations?: AnimationNode[];
+    logic?: LogicNode[];
+    parallels?: ParallelNode[];
+    build?: BuildNode | null;
+    evolve?: EvolveNode | null;
+    substates?: SubstateNode[];
+    classes?: ClassNode[];
+    loops?: LoopNode[];
+    events?: EventNode[];
+    syncs?: SyncNode[];
+    timeouts?: TimeoutNode[];
+    delays?: DelayNode[];
+    securities?: SecurityNode[];
+    keys?: KeyNode[];
+    sandboxes?: SandboxNode[];
+    causes?: CauseNode[];
+    consequences?: ConsequenceNode[];
+    memories?: MemoryNode[];
+    persists?: PersistNode[];
+    roots?: RootNode[];
+    interfaces?: InterfaceNode[];
+    visuals?: VisualNode[];
+    inputs?: InputNode[];
+    throttles?: ThrottleNode[];
+    boosts?: BoostNode[];
+    costs?: CostNode[];
+    locks?: LockNode[];
+    unlocks?: UnlockNode[];
+    voids?: VoidNode[];
+    inherits?: InheritNode[];
+    contains?: ContainsNode[];
+    verifies?: VerifyNode[];
+    logNodes?: LogNode[];
+    raw?: string;
+    isEny?: boolean;
+    logs?: LogEntry[];
+    errors?: string[];
+    nodes?: Array<FunctionNode | IANode | ModuleNode | ObjectNode | FormNode | AnimationNode | LogicNode | ParallelNode | BuildNode | EvolveNode | SubstateNode | ClassNode | LoopNode | EventNode | SyncNode | TimeoutNode | DelayNode | SecurityNode | KeyNode | SandboxNode | CauseNode | ConsequenceNode | MemoryNode | PersistNode | RootNode | InterfaceNode | VisualNode | InputNode | ThrottleNode | BoostNode | CostNode | LockNode | UnlockNode | VoidNode | InheritNode | ContainsNode | VerifyNode | LogNode | KernelNode | DatabaseNode | TrainingNode | {
+        type: string;
+        [k: string]: any;
+    }>;
+};
+
+/**
+ * runENY: wrapper that returns a parsed AST. Fast-fails if no `Σ SYSTEM` is found
+ */
+declare function runENY(code: string, options?: ParseOptions): EnyAST;
+
+declare function parse(code: string, options?: ParseOptions): EnyAST;
+
+declare enum TokenType {
+    SYMBOL = "SYMBOL",
+    IDENTIFIER = "IDENTIFIER",
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    ARROW = "ARROW",
+    LBRACE = "LBRACE",
+    RBRACE = "RBRACE",
+    COLON = "COLON",
+    COMMA = "COMMA",
+    LPAREN = "LPAREN",
+    RPAREN = "RPAREN",
+    LBRACKET = "LBRACKET",
+    RBRACKET = "RBRACKET",
+    NEWLINE = "NEWLINE",
+    COMPARATOR = "COMPARATOR",
+    OPERATOR = "OPERATOR",
+    EOF = "EOF"
+}
+interface Token {
+    type: TokenType;
+    value: string;
+    pos: number;
+}
+declare const SYMBOL_NAMES: Record<string, string>;
+declare function tokenize(input: string): Token[];
+
+interface TranspileOptions {
+    emitTypes?: boolean;
+    moduleFormat?: 'esm' | 'cjs';
+}
+declare function transpileToJS(ast: EnyAST, options?: TranspileOptions): string;
+/**
+ * Generate TypeScript declaration (.d.ts) content for the AST
+ */
+declare function transpileToDTS(ast: EnyAST): string;
+/**
+ * Generate WebAssembly Text Format (.wat) stub for the AST
+ * This is a placeholder for future WASM compilation
+ */
+declare function transpileToWAT(ast: EnyAST): string;
+/**
+ * Check if WASM target is requested in build configuration
+ */
+declare function hasWASMTarget(ast: EnyAST): boolean;
+
+/**
+ * IAProvider interface - base for all IA implementations
+ */
+interface IAProvider {
+    name: string;
+    /**
+     * Process an IA block and return a response
+     */
+    process(ia: IANode, context?: IAContext): Promise<IAResponse>;
+    /**
+     * Check if the provider is available/ready
+     */
+    isAvailable(): Promise<boolean>;
+}
+interface IAContext {
+    systemName?: string;
+    mode?: string;
+    onLog?: (entry: LogEntry) => void;
+}
+interface IAResponse {
+    success: boolean;
+    result?: any;
+    error?: string;
+    capabilities?: string[];
+}
+/**
+ * LocalIA - Mock implementation for testing and development
+ * Simulates IA behavior without external dependencies
+ */
+declare class LocalIA implements IAProvider {
+    name: string;
+    private capabilities;
+    constructor();
+    isAvailable(): Promise<boolean>;
+    process(ia: IANode, context?: IAContext): Promise<IAResponse>;
+    /**
+     * Register a custom capability handler
+     */
+    registerCapability(name: string, handler: () => any): void;
+}
+/**
+ * RemoteIA - Stub for future remote IA service integration
+ */
+declare class RemoteIA implements IAProvider {
+    name: string;
+    private endpoint;
+    private apiKey?;
+    constructor(endpoint: string, apiKey?: string);
+    isAvailable(): Promise<boolean>;
+    process(ia: IANode, context?: IAContext): Promise<IAResponse>;
+}
+/**
+ * IAManager - Manages IA providers and routes requests
+ */
+declare class IAManager {
+    private providers;
+    private defaultProvider;
+    constructor(defaultProvider?: IAProvider);
+    registerProvider(provider: IAProvider): void;
+    getProvider(name?: string): IAProvider;
+    processIA(ia: IANode, context?: IAContext, providerName?: string): Promise<IAResponse>;
+}
+declare const defaultIAManager: IAManager;
+/**
+ * Convenience function to process IA blocks
+ */
+declare function processIA(ia: IANode, context?: IAContext, provider?: IAProvider): Promise<IAResponse>;
+
+/**
+ * 🧬 SISTEMA DE EVOLUÇÃO AI-ENY
+ *
+ * O sistema de evolução permite transformações automáticas no AST.
+ * Comandos suportados:
+ *
+ * - rename <old> <new>     : Renomeia função
+ * - optimize <fn>          : Marca função para otimização
+ * - inline <fn>            : Marca função para inlining
+ * - memoize <fn>           : Adiciona memoização
+ * - parallelize <fn>       : Marca para execução paralela
+ * - deprecate <fn>         : Marca como deprecated
+ * - secure <fn>            : Adiciona validações de segurança
+ * - cache <object>         : Ativa cache para objeto
+ * - throttle <fn> <limit>  : Adiciona throttling
+ * - observe <target>       : Adiciona observabilidade
+ */
+interface EvolveResult {
+    changed: boolean;
+    appliedSteps: string[];
+    skippedSteps: string[];
+}
+declare function applyEvolve(ast: EnyAST, options?: {
+    onLog?: (e: LogEntry) => void;
+}): EvolveResult;
+
+/**
+ * 🧬 VALIDAÇÃO SEMÂNTICA DOS 9 PILARES AI-ENY
+ *
+ * Σ ESTADO     - Valida consistência de estados
+ * ƒ AÇÃO       - Valida funções e referências
+ * ■ FORMA      - Valida objetos e estruturas
+ * ⚡ TEMPO     - Valida eventos e causalidade
+ * Ψ ENERGIA    - Valida recursos e limites
+ * 𝓜 MEMÓRIA    - Valida persistência e cache
+ * ☐ INTERFACE  - Valida UI e inputs
+ * 🛡 SEGURANÇA - Valida regras de proteção
+ * ⟳ EVOLUÇÃO   - Valida passos de evolução
+ */
+interface ValidationResult {
+    errors: string[];
+    warnings: string[];
+    pillars: {
+        state: boolean;
+        action: boolean;
+        form: boolean;
+        time: boolean;
+        energy: boolean;
+        memory: boolean;
+        interface: boolean;
+        security: boolean;
+        evolve: boolean;
+    };
+    score: number;
+}
+declare function validateSemantic(ast: EnyAST, options?: ParseOptions): string[];
+declare function validateSemanticFull(ast: EnyAST, options?: ParseOptions): ValidationResult;
+
+/**
+ * Cria um sistema AI-ENY básico
+ */
+declare function createSystem(config: {
+    name: string;
+    mode?: 'development' | 'production' | 'autonomous';
+    ui?: 'auto' | 'minimal' | 'adaptive' | 'none';
+    evolve?: boolean;
+    targets?: string[];
+}): string;
+/**
+ * Obtém o estado atual de um AST
+ */
+declare function getState(ast: EnyAST): {
+    system: string | null | undefined;
+    mode: string | null | undefined;
+    ui: string | null | undefined;
+    version: string | null | undefined;
+    isEny: boolean | undefined;
+    substates: SubstateNode[];
+};
+/**
+ * Cria uma função AI-ENY
+ */
+declare function createFunction(name: string, args: string[], steps: string[]): string;
+/**
+ * Obtém todas as funções do AST
+ */
+declare function getFunctions(ast: EnyAST): FunctionNode[];
+/**
+ * Cria um objeto AI-ENY
+ */
+declare function createObject(name: string, props: Record<string, any>): string;
+/**
+ * Cria uma classe AI-ENY
+ */
+declare function createClass(name: string, props: Record<string, any>, methods?: string[], extendsClass?: string): string;
+/**
+ * Obtém todas as estruturas (objetos, classes) do AST
+ */
+declare function getStructures(ast: EnyAST): {
+    objects: ObjectNode[];
+    classes: ClassNode[];
+    modules: ModuleNode[];
+};
+/**
+ * Cria um evento AI-ENY
+ */
+declare function createEvent(name: string, handlers: string[]): string;
+/**
+ * Cria um loop AI-ENY
+ */
+declare function createLoop(count: number, body: string[]): string;
+/**
+ * Obtém todos os elementos temporais
+ */
+declare function getTemporals(ast: EnyAST): {
+    events: EventNode[];
+    loops: LoopNode[];
+    causes: CauseNode[];
+    timeouts: TimeoutNode[];
+    delays: DelayNode[];
+    syncs: SyncNode[];
+};
+/**
+ * Cria um throttle AI-ENY
+ */
+declare function createThrottle(target: string, limit: number): string;
+/**
+ * Cria um boost AI-ENY
+ */
+declare function createBoost(target: string, factor: number): string;
+/**
+ * Obtém informações de energia/recursos
+ */
+declare function getEnergy(ast: EnyAST): {
+    throttles: ThrottleNode[];
+    boosts: BoostNode[];
+    costs: CostNode[];
+};
+/**
+ * Cria uma memória AI-ENY
+ */
+declare function createMemory(name: string, size: number, persist?: boolean): string;
+/**
+ * Cria persistência AI-ENY
+ */
+declare function createPersist(target: string, storage?: 'db' | 'file' | 'cache'): string;
+/**
+ * Obtém informações de memória
+ */
+declare function getMemory(ast: EnyAST): {
+    database: DatabaseNode | null | undefined;
+    memories: MemoryNode[];
+    persists: PersistNode[];
+};
+/**
+ * Cria um input AI-ENY
+ */
+declare function createInput(name: string, type?: 'text' | 'number' | 'email' | 'password'): string;
+/**
+ * Cria um visual AI-ENY
+ */
+declare function createVisual(name: string, props: Record<string, any>): string;
+/**
+ * Obtém informações de interface
+ */
+declare function getInterface(ast: EnyAST): {
+    forms: FormNode[];
+    inputs: InputNode[];
+    visuals: VisualNode[];
+    interfaces: InterfaceNode[];
+};
+/**
+ * Cria uma regra de segurança AI-ENY
+ */
+declare function createSecurity(level: 'low' | 'medium' | 'high' | 'critical', rules: string[]): string;
+/**
+ * Cria uma chave AI-ENY
+ */
+declare function createKey(name: string, permissions: string[]): string;
+/**
+ * Obtém informações de segurança
+ */
+declare function getSecurity(ast: EnyAST): {
+    securities: SecurityNode[];
+    keys: KeyNode[];
+    sandboxes: SandboxNode[];
+    locks: LockNode[];
+    unlocks: UnlockNode[];
+};
+/**
+ * Cria um bloco de evolução AI-ENY
+ */
+declare function createEvolve(steps: string[]): string;
+/**
+ * Obtém informações de evolução
+ */
+declare function getEvolve(ast: EnyAST): {
+    evolve: EvolveNode | null | undefined;
+    verifies: VerifyNode[];
+    logNodes: LogNode[];
+};
+/**
+ * Gera código AI-ENY completo a partir de configuração
+ */
+declare function generateENY(config: {
+    system: {
+        name: string;
+        mode?: string;
+        ui?: string;
+    };
+    functions?: Array<{
+        name: string;
+        args?: string[];
+        steps: string[];
+    }>;
+    objects?: Array<{
+        name: string;
+        props: Record<string, any>;
+    }>;
+    events?: Array<{
+        name: string;
+        handlers: string[];
+    }>;
+    security?: {
+        level: string;
+        rules: string[];
+    };
+    evolve?: string[];
+}): string;
+
+/**
+ * ENY-AI Core Library
+ * Biblioteca Universal de Sistemas Autogeráveis
+ * Código 90% Simbólico baseado no Alfabeto AI-X
+ */
+
+declare const VERSION = "1.0.0";
+declare const NAME = "eny-ai";
+declare const STATE: unique symbol;
+declare const SUBSTATE: unique symbol;
+declare const VOID_VAL: null;
+declare const TRUE_VAL = true;
+declare const FALSE_VAL = false;
+declare const OBJECT: unique symbol;
+declare const FUNCTION: unique symbol;
+declare const INTERFACE: unique symbol;
+declare const SHIELD: unique symbol;
+declare const EVOLVE: unique symbol;
+
+/** Cria um sistema ENY rápido */
+declare function quickSystem(name: string, config?: {
+    mode?: 'development' | 'production' | 'autonomous';
+    ui?: 'auto' | 'adaptive' | 'minimal';
+    evolve?: boolean;
+}): string;
+/** Executa código ENY e retorna JavaScript transpilado */
+declare function compile(enyCode: string): string;
+/** Verifica se código é válido ENY */
+declare function isValidENY(code: string): boolean;
+
+export { type AnimationNode, type BoostNode, type BuildNode, type CauseNode, type ClassNode, type ConsequenceNode, type ContainsNode, type CostNode, type DatabaseNode, type DelayNode, EVOLVE, type EnyAST, type EventNode, type EvolveNode, type EvolveResult, FALSE_VAL, FUNCTION, type FormNode, type FunctionNode, type IAContext, IAManager, type IANode, type IAProvider, type IAResponse, INTERFACE, type InheritNode, type InputNode, type InterfaceNode, type KernelNode, type KeyNode, LocalIA, type LockNode, type LogEntry, type LogNode, type LogicNode, type LoopNode, type MemoryNode, type ModuleNode, NAME, OBJECT, type ObjectNode, type ParallelNode, type ParseOptions, type PersistNode, RemoteIA, type RootNode, SHIELD, STATE, SUBSTATE, SYMBOL_NAMES, type SandboxNode, type SecurityNode, type Step, type SubstateNode, type SyncNode, TRUE_VAL, type ThrottleNode, type TimeoutNode, type Token, TokenType, type TrainingNode, type TranspileOptions, type UnlockNode, VERSION, VOID_VAL, type ValidationResult, type VerifyNode, type VisualNode, type VoidNode, applyEvolve, compile, createBoost, createClass, createEvent, createEvolve, createFunction, createInput, createKey, createLoop, createMemory, createObject, createPersist, createSecurity, createSystem, createThrottle, createVisual, defaultIAManager, generateENY, getEnergy, getEvolve, getFunctions, getInterface, getMemory, getSecurity, getState, getStructures, getTemporals, hasWASMTarget, isValidENY, parse, processIA, quickSystem, runENY, tokenize, transpileToDTS, transpileToJS, transpileToWAT, validateSemantic, validateSemanticFull };