enyosx-ai 0.1.0

package/dist/index.js

@@ -0,0 +1,379 @@
+import {
+  SYMBOL_NAMES,
+  TokenType,
+  applyEvolve,
+  hasWASMTarget,
+  parse,
+  runENY,
+  tokenize,
+  transpileToDTS,
+  transpileToJS,
+  transpileToWAT,
+  validateSemantic,
+  validateSemanticFull
+} from "./chunk-O5XZOSBW.js";
+
+// src/ia/index.ts
+var LocalIA = class {
+  constructor() {
+    this.name = "LocalIA";
+    this.capabilities = /* @__PURE__ */ new Map();
+    this.capabilities.set("aprender", () => ({ learned: true }));
+    this.capabilities.set("sugerir", () => ({ suggestions: ["option1", "option2"] }));
+    this.capabilities.set("evoluir", () => ({ evolved: true }));
+    this.capabilities.set("analisar", () => ({ analysis: "completed" }));
+    this.capabilities.set("prever", () => ({ prediction: "success" }));
+    this.capabilities.set("otimizar", () => ({ optimized: true }));
+  }
+  async isAvailable() {
+    return true;
+  }
+  async process(ia, context) {
+    const log = context?.onLog;
+    if (log) {
+      log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "info",
+        event: "ia.process.start",
+        detail: { name: ia.name, capabilities: ia.body }
+      });
+    }
+    const results = {};
+    const processedCapabilities = [];
+    for (const capability of ia.body) {
+      const capName = capability.split(/\s+/)[0].toLowerCase();
+      const handler = this.capabilities.get(capName);
+      if (handler) {
+        results[capName] = handler();
+        processedCapabilities.push(capName);
+        if (log) {
+          log({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            level: "debug",
+            event: "ia.capability.executed",
+            detail: { capability: capName, result: results[capName] }
+          });
+        }
+      } else {
+        results[capName] = { status: "acknowledged", raw: capability };
+        processedCapabilities.push(capName);
+        if (log) {
+          log({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            level: "warn",
+            event: "ia.capability.unknown",
+            detail: { capability: capName, raw: capability }
+          });
+        }
+      }
+    }
+    if (log) {
+      log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "info",
+        event: "ia.process.complete",
+        detail: { name: ia.name, processedCount: processedCapabilities.length }
+      });
+    }
+    return {
+      success: true,
+      result: results,
+      capabilities: processedCapabilities
+    };
+  }
+  /**
+   * Register a custom capability handler
+   */
+  registerCapability(name, handler) {
+    this.capabilities.set(name.toLowerCase(), handler);
+  }
+};
+var RemoteIA = class {
+  constructor(endpoint, apiKey) {
+    this.name = "RemoteIA";
+    this.endpoint = endpoint;
+    this.apiKey = apiKey;
+  }
+  async isAvailable() {
+    return false;
+  }
+  async process(ia, context) {
+    const log = context?.onLog;
+    if (log) {
+      log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "warn",
+        event: "ia.remote.notImplemented",
+        detail: { endpoint: this.endpoint }
+      });
+    }
+    return {
+      success: false,
+      error: "RemoteIA is not implemented yet. Use LocalIA for development."
+    };
+  }
+};
+var IAManager = class {
+  constructor(defaultProvider) {
+    this.providers = /* @__PURE__ */ new Map();
+    this.defaultProvider = defaultProvider || new LocalIA();
+    this.providers.set(this.defaultProvider.name, this.defaultProvider);
+  }
+  registerProvider(provider) {
+    this.providers.set(provider.name, provider);
+  }
+  getProvider(name) {
+    if (name && this.providers.has(name)) {
+      return this.providers.get(name);
+    }
+    return this.defaultProvider;
+  }
+  async processIA(ia, context, providerName) {
+    const provider = this.getProvider(providerName);
+    const available = await provider.isAvailable();
+    if (!available) {
+      if (provider.name !== "LocalIA") {
+        const localIA = this.providers.get("LocalIA") || new LocalIA();
+        return localIA.process(ia, context);
+      }
+      return {
+        success: false,
+        error: `Provider ${provider.name} is not available`
+      };
+    }
+    return provider.process(ia, context);
+  }
+};
+var defaultIAManager = new IAManager();
+async function processIA(ia, context, provider) {
+  const p = provider || new LocalIA();
+  return p.process(ia, context);
+}
+
+// src/pillars.ts
+function createSystem(config) {
+  const lines = [];
+  lines.push(`\u03A3 SYSTEM "${config.name}"`);
+  if (config.mode)
+    lines.push(`\u03A3 MODE ${config.mode}`);
+  if (config.ui)
+    lines.push(`\u03A3 UI ${config.ui}`);
+  if (config.evolve)
+    lines.push(`\u03A3 EVOLVE true`);
+  if (config.targets?.length) {
+    lines.push(`\u03A3 TARGET ${config.targets.join(" + ")}`);
+  }
+  return lines.join("\n");
+}
+function getState(ast) {
+  return {
+    system: ast.system,
+    mode: ast.mode,
+    ui: ast.ui,
+    version: ast.version,
+    isEny: ast.isEny,
+    substates: ast.substates || []
+  };
+}
+function createFunction(name, args, steps) {
+  const argsStr = args.length ? `(${args.join(", ")})` : "";
+  const stepsStr = steps.map((s) => `  \u2192 ${s}`).join("\n");
+  return `\u0394 function ${name}${argsStr}
+${stepsStr}`;
+}
+function getFunctions(ast) {
+  return ast.functions || [];
+}
+function createObject(name, props) {
+  const propsStr = Object.entries(props).map(([k, v]) => `  ${k}: ${JSON.stringify(v)}`).join("\n");
+  return `\u03A9 ${name} {
+${propsStr}
+}`;
+}
+function createClass(name, props, methods = [], extendsClass) {
+  const extendsStr = extendsClass ? ` \u2192 ${extendsClass}` : "";
+  const propsStr = Object.entries(props).map(([k, v]) => `  ${k}: ${typeof v}`).join("\n");
+  const methodsStr = methods.map((m) => `  ${m}()`).join("\n");
+  return `\u25CB ${name}${extendsStr} {
+${propsStr}
+${methodsStr}
+}`;
+}
+function getStructures(ast) {
+  return {
+    objects: ast.objects || [],
+    classes: ast.classes || [],
+    modules: ast.modules || []
+  };
+}
+function createEvent(name, handlers) {
+  const handlersStr = handlers.map((h) => `  \u2192 ${h}`).join("\n");
+  return `\u25CC ${name}
+${handlersStr}`;
+}
+function createLoop(count, body) {
+  const bodyStr = body.map((b) => `  ${b}`).join("\n");
+  return `\u21BB ${count} {
+${bodyStr}
+}`;
+}
+function getTemporals(ast) {
+  return {
+    events: ast.events || [],
+    loops: ast.loops || [],
+    causes: ast.causes || [],
+    timeouts: ast.timeouts || [],
+    delays: ast.delays || [],
+    syncs: ast.syncs || []
+  };
+}
+function createThrottle(target, limit) {
+  return `\u23EC ${target} ${limit}`;
+}
+function createBoost(target, factor) {
+  return `\u23EB ${target} ${factor}`;
+}
+function getEnergy(ast) {
+  return {
+    throttles: ast.throttles || [],
+    boosts: ast.boosts || [],
+    costs: ast.costs || []
+  };
+}
+function createMemory(name, size, persist = false) {
+  return `\u{1D4DC} ${name} ${size}${persist ? " persist" : ""}`;
+}
+function createPersist(target, storage = "db") {
+  return `\u267E ${target} ${storage}`;
+}
+function getMemory(ast) {
+  return {
+    database: ast.database,
+    memories: ast.memories || [],
+    persists: ast.persists || []
+  };
+}
+function createInput(name, type = "text") {
+  return `\u2328 ${name} ${type}`;
+}
+function createVisual(name, props) {
+  const propsStr = Object.entries(props).map(([k, v]) => `  ${k}: ${v}`).join("\n");
+  return `\u{1F441} ${name} {
+${propsStr}
+}`;
+}
+function getInterface(ast) {
+  return {
+    forms: ast.forms || [],
+    inputs: ast.inputs || [],
+    visuals: ast.visuals || [],
+    interfaces: ast.interfaces || []
+  };
+}
+function createSecurity(level, rules) {
+  const rulesStr = rules.map((r) => `  ${r}`).join("\n");
+  return `\u{1F6E1} ${level} {
+${rulesStr}
+}`;
+}
+function createKey(name, permissions) {
+  const permsStr = permissions.map((p) => `  ${p}`).join("\n");
+  return `\u{1F511} ${name} {
+${permsStr}
+}`;
+}
+function getSecurity(ast) {
+  return {
+    securities: ast.securities || [],
+    keys: ast.keys || [],
+    sandboxes: ast.sandboxes || [],
+    locks: ast.locks || [],
+    unlocks: ast.unlocks || []
+  };
+}
+function createEvolve(steps) {
+  const stepsStr = steps.map((s) => `  ${s}`).join("\n");
+  return `\u27F3 {
+${stepsStr}
+}`;
+}
+function getEvolve(ast) {
+  return {
+    evolve: ast.evolve,
+    verifies: ast.verifies || [],
+    logNodes: ast.logNodes || []
+  };
+}
+function generateENY(config) {
+  const parts = [];
+  parts.push(`\u03A3 SYSTEM "${config.system.name}"`);
+  if (config.system.mode)
+    parts.push(`\u03A3 MODE ${config.system.mode}`);
+  if (config.system.ui)
+    parts.push(`\u03A3 UI ${config.system.ui}`);
+  parts.push("");
+  for (const fn of config.functions || []) {
+    parts.push(createFunction(fn.name, fn.args || [], fn.steps));
+    parts.push("");
+  }
+  for (const obj of config.objects || []) {
+    parts.push(createObject(obj.name, obj.props));
+    parts.push("");
+  }
+  for (const evt of config.events || []) {
+    parts.push(createEvent(evt.name, evt.handlers));
+    parts.push("");
+  }
+  if (config.security) {
+    parts.push(createSecurity(config.security.level, config.security.rules));
+    parts.push("");
+  }
+  if (config.evolve?.length) {
+    parts.push(createEvolve(config.evolve));
+  }
+  return parts.join("\n").trim();
+}
+export {
+  IAManager,
+  LocalIA,
+  RemoteIA,
+  SYMBOL_NAMES,
+  TokenType,
+  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
+};

package/dist/parser-4JXKOWKY.js

@@ -0,0 +1,8 @@
+import {
+  parse,
+  writeWithRetry
+} from "./chunk-HR4G5XQI.js";
+export {
+  parse,
+  writeWithRetry
+};

package/dist/parser-UUB6D2CZ.js

@@ -0,0 +1,8 @@
+import {
+  parse,
+  writeWithRetry
+} from "./chunk-2WM5L76D.js";
+export {
+  parse,
+  writeWithRetry
+};

package/dist/parser-V44AIVNI.js

@@ -0,0 +1,8 @@
+import {
+  parse,
+  writeWithRetry
+} from "./chunk-76PHNPTY.js";
+export {
+  parse,
+  writeWithRetry
+};

package/examples/README.md

@@ -0,0 +1,13 @@
+# Examples
+
+This folder contains simple examples to try the CLI and API.
+
+- `sample.eny` — a compact language sample covering system, module, object, form, function, parallel and build.
+- `starter.eny` — a minimal starter app example for experimenting.
+
+Usage:
+
+```bash
+node ./dist/cli.js examples/sample.eny
+node ./dist/cli.js examples/starter.eny --emit js --out starter.js
+```

package/examples/ia-demo.eny

@@ -0,0 +1,37 @@
+Σ SYSTEM "IA Demo"
+Σ MODE autonomous
+Σ UI dashboard
+
+Ψ IA vendas {
+  aprender clientes
+  sugerir ofertas
+  evoluir estratégias
+}
+
+Ψ IA analytics {
+  analisar dados
+  prever tendências
+  otimizar processos
+}
+
+Δ iniciarIA()
+  → carregarModelos
+  → ativarIA
+
+Δ carregarModelos()
+  → loadVendas
+  → loadAnalytics
+
+Δ loadVendas()
+  → done
+
+Δ loadAnalytics()
+  → done
+
+Δ ativarIA()
+  → processarFila
+
+Δ processarFila()
+  → done
+
+Δ done()

package/examples/sample.eny

@@ -0,0 +1,15 @@
+Σ SYSTEM "Example App"
+Σ MODULE "Demo"
+Ω User { nome email }
+Φ UI { layout: dashboard }
+Δ iniciar()
+  → carregar
+  → iniciarApp
+⊗ {
+  gerar imagem
+  gerar 3D
+}
+Σ BUILD {
+  target: wasm
+  target: js
+}

package/examples/simple/system.eny

@@ -0,0 +1,7 @@
+Σ SYSTEM "Exemplo Marketplace"
+Σ MODE autonomous
+Σ UI adaptive
+
+Ψ IA vendas {
+  aprender clientes
+}

package/examples/spec/sample.eny

@@ -0,0 +1,19 @@
+Σ SYSTEM "Studio Neural"
+Σ TARGET web desktop
+Σ UI adaptive
+Σ IA creative
+Σ EVOLVE true
+
+Ω User { nome email }
+
+Φ UI { layout: canvas }
+
+Ψ IA "Criador" {
+  gerar imagens
+  gerar 3D
+  gerar animações
+}
+
+Θ animation "intro"
+
+→ iniciar sistema

package/examples/starter/README.md

@@ -0,0 +1,96 @@
+# Starter Example
+
+Este é um projeto exemplo para começar a usar a biblioteca AI-ENY (enyosx-ai).
+
+## Estrutura
+
+```
+starter/
+├── main.eny          # Sistema principal AI-ENY
+├── run.js            # Script de execução Node.js
+└── README.md         # Este arquivo
+```
+
+## Instalação
+
+```bash
+# Instale a biblioteca
+npm install enyosx-ai
+
+# Ou globalmente para usar a CLI
+npm install -g enyosx-ai
+```
+
+## Uso
+
+### Via CLI
+
+```bash
+# Parsear e mostrar AST
+npx enyosx-ai main.eny
+
+# Transpilar para JavaScript
+npx enyosx-ai main.eny --emit js --out output.js
+
+# Gerar tipos TypeScript
+npx enyosx-ai main.eny --emit dts --out output.d.ts
+
+# Gerar stub WASM
+npx enyosx-ai main.eny --emit wasm --out output.wat
+```
+
+### Via JavaScript/TypeScript
+
+```bash
+node run.js
+```
+
+## Arquivo main.eny
+
+```eny
+Σ SYSTEM "Starter App"
+Σ MODE development
+Σ UI auto
+
+Δ inicializar()
+  → configurar
+  → iniciar
+
+Δ configurar()
+  → carregarConfigs
+
+Δ carregarConfigs()
+  → validar
+
+Δ validar()
+  → done
+
+Δ iniciar()
+  → executarApp
+
+Δ executarApp()
+  → done
+
+Δ done()
+
+Ψ IA assistente {
+  aprender contexto
+  sugerir acoes
+}
+
+Ω Config {
+  ambiente: dev
+  debug: true
+}
+
+Σ BUILD {
+  target: js
+  target: wasm
+}
+```
+
+## Próximos Passos
+
+1. Modifique `main.eny` para seu caso de uso
+2. Use a CLI para transpilar para JS ou WASM
+3. Integre com seu projeto Node.js ou React

package/examples/starter/main.eny

@@ -0,0 +1,39 @@
+Σ SYSTEM "Starter App"
+Σ MODE development
+Σ UI auto
+
+Δ inicializar()
+  → configurar
+  → iniciar
+
+Δ configurar()
+  → carregarConfigs
+
+Δ carregarConfigs()
+  → validar
+
+Δ validar()
+  → done
+
+Δ iniciar()
+  → executarApp
+
+Δ executarApp()
+  → done
+
+Δ done()
+
+Ψ IA assistente {
+  aprender contexto
+  sugerir acoes
+}
+
+Ω Config {
+  ambiente: dev
+  debug: true
+}
+
+Σ BUILD {
+  target: js
+  target: wasm
+}

package/examples/starter/run.js

@@ -0,0 +1,68 @@
+// Starter example - Node.js script
+const fs = require('fs');
+const path = require('path');
+
+// Import enyosx-ai (use require for commonjs compatibility)
+let runENY, transpileToJS, transpileToDTS, transpileToWAT, LocalIA;
+
+try {
+  const lib = require('enyosx-ai');
+  runENY = lib.runENY;
+  transpileToJS = lib.transpileToJS;
+  transpileToDTS = lib.transpileToDTS;
+  transpileToWAT = lib.transpileToWAT;
+  LocalIA = lib.LocalIA;
+} catch (e) {
+  // Fallback for local development
+  const lib = require('../../dist/index.cjs');
+  runENY = lib.runENY;
+  transpileToJS = lib.transpileToJS;
+  transpileToDTS = lib.transpileToDTS;
+  transpileToWAT = lib.transpileToWAT;
+  LocalIA = lib.LocalIA;
+}
+
+// Read the main.eny file
+const enyPath = path.join(__dirname, 'main.eny');
+const code = fs.readFileSync(enyPath, 'utf-8');
+
+console.log('=== AI-ENY Starter Example ===\n');
+
+// Parse the code
+const ast = runENY(code, { 
+  verbose: true,
+  onLog: (entry) => {
+    console.log(`[${entry.level.toUpperCase()}] ${entry.event}`);
+  }
+});
+
+console.log('\n=== Parsed AST ===');
+console.log(`System: ${ast.system}`);
+console.log(`Mode: ${ast.mode}`);
+console.log(`Functions: ${ast.functions?.map(f => f.name).join(', ')}`);
+console.log(`IAs: ${ast.ias?.map(ia => ia.name).join(', ')}`);
+console.log(`Objects: ${ast.objects?.map(o => o.name).join(', ')}`);
+console.log(`Build targets: ${ast.build?.targets?.join(', ')}`);
+
+// Transpile to JS
+console.log('\n=== Transpiled JS (preview) ===');
+const js = transpileToJS(ast);
+console.log(js.substring(0, 500) + '...');
+
+// Process IA blocks
+if (ast.ias && ast.ias.length > 0) {
+  console.log('\n=== Processing IA blocks ===');
+  const ia = new LocalIA();
+  
+  for (const iaNode of ast.ias) {
+    console.log(`\nProcessing IA: ${iaNode.name}`);
+    ia.process(iaNode, {
+      onLog: (e) => console.log(`  [IA] ${e.event}`)
+    }).then(result => {
+      console.log(`  Result: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+      console.log(`  Capabilities processed: ${result.capabilities?.join(', ')}`);
+    });
+  }
+}
+
+console.log('\n=== Done ===');