enyosx-ai 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,672 @@
+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;
+
+export { AnimationNode, BoostNode, BuildNode, CauseNode, ClassNode, ConsequenceNode, ContainsNode, CostNode, DatabaseNode, DelayNode, EnyAST, EventNode, EvolveNode, EvolveResult, FormNode, FunctionNode, IAContext, IAManager, IANode, IAProvider, IAResponse, InheritNode, InputNode, InterfaceNode, KernelNode, KeyNode, LocalIA, LockNode, LogEntry, LogNode, LogicNode, LoopNode, MemoryNode, ModuleNode, ObjectNode, ParallelNode, ParseOptions, PersistNode, RemoteIA, RootNode, SYMBOL_NAMES, SandboxNode, SecurityNode, Step, SubstateNode, SyncNode, ThrottleNode, TimeoutNode, Token, TokenType, TrainingNode, TranspileOptions, UnlockNode, ValidationResult, VerifyNode, VisualNode, VoidNode, applyEvolve, 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, parse, processIA, runENY, tokenize, transpileToDTS, transpileToJS, transpileToWAT, validateSemantic, validateSemanticFull };