eny-ai 1.0.0

package/dist/index.js

@@ -0,0 +1,495 @@
+import {
+  SYMBOL_NAMES,
+  TokenType,
+  applyEvolve,
+  hasWASMTarget,
+  init_parser,
+  init_tokenize,
+  init_transpile,
+  parse,
+  parser_exports,
+  runENY,
+  tokenize,
+  transpileToDTS,
+  transpileToJS,
+  transpileToWAT,
+  transpile_exports,
+  validateSemantic,
+  validateSemanticFull
+} from "./chunk-2WFUL4XJ.js";
+import {
+  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 "./chunk-E4KJZEXX.js";
+import {
+  __toCommonJS
+} from "./chunk-PNKVD2UK.js";
+
+// src/index.ts
+init_parser();
+init_tokenize();
+init_transpile();
+
+// 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 log2 = context?.onLog;
+    if (log2) {
+      log2({
+        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 (log2) {
+          log2({
+            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 (log2) {
+          log2({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            level: "warn",
+            event: "ia.capability.unknown",
+            detail: { capability: capName, raw: capability }
+          });
+        }
+      }
+    }
+    if (log2) {
+      log2({
+        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 log2 = context?.onLog;
+    if (log2) {
+      log2({
+        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 fn2 of config.functions || []) {
+    parts.push(createFunction(fn2.name, fn2.args || [], fn2.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();
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+var NAME = "eny-ai";
+var STATE = /* @__PURE__ */ Symbol("STATE");
+var SUBSTATE = /* @__PURE__ */ Symbol("SUBSTATE");
+var VOID_VAL = null;
+var TRUE_VAL = true;
+var FALSE_VAL = false;
+var OBJECT = /* @__PURE__ */ Symbol("OBJECT");
+var FUNCTION = /* @__PURE__ */ Symbol("FUNCTION");
+var INTERFACE = /* @__PURE__ */ Symbol("INTERFACE");
+var SHIELD = /* @__PURE__ */ Symbol("SECURITY");
+var EVOLVE = /* @__PURE__ */ Symbol("EVOLVE");
+function quickSystem(name, config) {
+  return createSystem({
+    name,
+    mode: config?.mode || "development",
+    ui: config?.ui || "auto",
+    evolve: config?.evolve || false
+  });
+}
+function compile(enyCode) {
+  const { transpileToJS: transpileToJS2 } = (init_transpile(), __toCommonJS(transpile_exports));
+  const { parse: parse2 } = (init_parser(), __toCommonJS(parser_exports));
+  const ast = parse2(enyCode);
+  return transpileToJS2(ast);
+}
+function isValidENY(code) {
+  try {
+    const { parse: parse2 } = (init_parser(), __toCommonJS(parser_exports));
+    const ast = parse2(code);
+    return ast.isEny === true;
+  } catch {
+    return false;
+  }
+}
+export {
+  ALPHABET,
+  EVOLVE,
+  FALSE,
+  FALSE_VAL,
+  FUNCTION,
+  IAManager,
+  INTERFACE,
+  LocalIA,
+  NAME,
+  NIL,
+  OBJECT,
+  RemoteIA,
+  SHIELD,
+  STATE,
+  SUBSTATE,
+  SYMBOLS,
+  SYMBOL_NAMES,
+  TRANSPILE_MAP,
+  TRUE,
+  TRUE_VAL,
+  TokenType,
+  VERSION,
+  VOID,
+  VOID_VAL,
+  applyEvolve,
+  asyncFn,
+  compile,
+  component,
+  createBoost,
+  createClass,
+  createEvent,
+  createEvolve,
+  createFunction,
+  createInput,
+  createKey,
+  createLoop,
+  createMemory,
+  createObject,
+  createPersist,
+  createSecurity,
+  createSystem,
+  createThrottle,
+  createVisual,
+  defaultIAManager,
+  effect,
+  error,
+  filter,
+  find,
+  fn,
+  generateENY,
+  get,
+  getEnergy,
+  getEvolve,
+  getFunctions,
+  getInterface,
+  getMemory,
+  getSecurity,
+  getState,
+  getStructures,
+  getTemporals,
+  hasWASMTarget,
+  isValidENY,
+  log,
+  map,
+  navigate,
+  parse,
+  post,
+  processIA,
+  quickSystem,
+  reduce,
+  runENY,
+  shape,
+  state,
+  storageGet,
+  storageSet,
+  toSymbolic,
+  tokenize,
+  transpileSymbols,
+  transpileToDTS,
+  transpileToJS,
+  transpileToWAT,
+  validate,
+  validateSemantic,
+  validateSemanticFull
+};