enyosx-ai 0.1.0

package/dist/chunk-4ZV5JV6W.js

@@ -0,0 +1,298 @@
+// src/parser.ts
+function parse(code, options) {
+  const logs = [];
+  const log = (entry) => {
+    const e = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...entry };
+    logs.push(e);
+    if (options?.onLog)
+      options.onLog(e);
+  };
+  log({ level: "info", event: "parse.start", detail: { length: code.length } });
+  const ast = {
+    raw: code,
+    functions: [],
+    ias: [],
+    nodes: [],
+    modules: [],
+    objects: [],
+    forms: [],
+    animations: [],
+    logic: [],
+    parallels: [],
+    build: null,
+    evolve: null,
+    targets: [],
+    version: null,
+    logs
+  };
+  const lines = code.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const raw = lines[i];
+    const line = raw.trim();
+    if (!line) {
+      i++;
+      continue;
+    }
+    if (/^Σ\s+SYSTEM/i.test(line)) {
+      const m = line.match(/^Σ\s+SYSTEM\s+"([^"]+)"/i);
+      ast.system = m ? m[1] : line.replace(/^Σ\s+SYSTEM\s*/i, "");
+      log({ level: "info", event: "parse.system", i, line: ast.system });
+      i++;
+      continue;
+    }
+    if (/^Σ\s+VERSION/i.test(line)) {
+      const m = line.match(/^Σ\s+VERSION\s+([\d\.]+)/i);
+      ast.version = m ? m[1] : null;
+      i++;
+      continue;
+    }
+    if (/^Σ\s+TARGET/i.test(line)) {
+      const m = line.match(/^Σ\s+TARGET\s+(.+)/i);
+      if (m) {
+        const parts = m[1].split(/[+,\s]+/).map((s) => s.trim()).filter(Boolean);
+        ast.targets = [...ast.targets || [], ...parts];
+      }
+      i++;
+      continue;
+    }
+    if (/^Σ\s+MODE/i.test(line)) {
+      const m = line.match(/^Σ\s+MODE\s+([\w-]+)/i);
+      ast.mode = m ? m[1] : null;
+      i++;
+      continue;
+    }
+    if (/^Σ\s+UI/i.test(line)) {
+      const m = line.match(/^Σ\s+UI\s+([\w-]+)/i);
+      ast.ui = m ? m[1] : null;
+      i++;
+      continue;
+    }
+    if (/^Δ\s+([\w_]+)\s*\(([^)]*)\)/.test(line)) {
+      const m = line.match(/^Δ\s+([\w_]+)\s*\(([^)]*)\)/);
+      const name = m ? m[1] : "anonymous";
+      const argsRaw = m ? m[2] : "";
+      const args = argsRaw ? argsRaw.split(",").map((s) => s.trim()).filter(Boolean) : [];
+      const steps = [];
+      log({ level: "info", event: "parse.function.start", i, detail: { name, args } });
+      i++;
+      while (i < lines.length) {
+        const l = lines[i];
+        if (!l.trim()) {
+          i++;
+          continue;
+        }
+        if (/^→/.test(l.trim()) || /^\s+→/.test(l) || /^\s+/.test(l)) {
+          const step = l.trim().replace(/^→\s?/, "");
+          steps.push({ raw: step });
+          log({ level: "debug", event: "parse.function.step", i, line: step });
+          i++;
+        } else {
+          break;
+        }
+      }
+      const fn = { type: "function", name, args, steps };
+      log({ level: "info", event: "parse.function.end", detail: fn });
+      ast.functions.push(fn);
+      ast.nodes.push(fn);
+      continue;
+    }
+    if (/^Ψ\s+IA\s+([\w-]+)\s*\{?/.test(line)) {
+      const m = line.match(/^Ψ\s+IA\s+([\w-]+)\s*\{?/);
+      const name = m ? m[1] : "ia";
+      const body = [];
+      if (/\{$/.test(line)) {
+        i++;
+        while (i < lines.length && !/\}/.test(lines[i])) {
+          body.push(lines[i].trim());
+          i++;
+        }
+        if (i < lines.length && /\}/.test(lines[i]))
+          i++;
+      } else {
+        i++;
+        while (i < lines.length) {
+          const l = lines[i];
+          if (!l.trim()) {
+            i++;
+            break;
+          }
+          if (/^Σ|^Δ|^Ψ/.test(l.trim()))
+            break;
+          body.push(l.trim());
+          i++;
+        }
+      }
+      const ia = { type: "ia", name, body };
+      log({ level: "info", event: "parse.ia", i, detail: ia });
+      ast.ias.push(ia);
+      ast.nodes.push(ia);
+      continue;
+    }
+    if (/^Σ\s+EVOLVE/i.test(line)) {
+      const steps = [];
+      i++;
+      while (i < lines.length && !!lines[i].trim() && !/^Σ|^Δ|^Ψ|Ω|Φ|Θ|Λ|⊗/.test(lines[i].trim())) {
+        steps.push(lines[i].trim());
+        i++;
+      }
+      const ev = { type: "evolve", steps };
+      ast.evolve = ev;
+      ast.nodes.push(ev);
+      continue;
+    }
+    if (/^Σ\s+BUILD/i.test(line)) {
+      const targets = [];
+      i++;
+      while (i < lines.length && !!lines[i].trim() && !/^Σ|^Δ|^Ψ|Ω|Φ|Θ|Λ|⊗/.test(lines[i].trim())) {
+        const m = lines[i].trim().match(/target:\s*([\w-]+)/);
+        if (m)
+          targets.push(m[1]);
+        i++;
+      }
+      const b = { type: "build", targets };
+      log({ level: "info", event: "parse.build", i, detail: b });
+      ast.build = b;
+      ast.nodes.push(b);
+      continue;
+    }
+    if (/^Σ\s+MODULE/i.test(line)) {
+      const m = line.match(/^Σ\s+MODULE\s+"([^"]+)"/i);
+      const name = m ? m[1] : line.replace(/^Σ\s+MODULE\s*/i, "");
+      const module = { type: "module", name };
+      ast.modules.push(module);
+      ast.nodes.push(module);
+      i++;
+      continue;
+    }
+    if (/^Ω\s+([\w_]+)\s*\{?/.test(line)) {
+      const m = line.match(/^Ω\s+([\w_]+)\s*\{?/);
+      const name = m ? m[1] : "object";
+      const props = {};
+      if (/\{$/.test(line)) {
+        i++;
+        while (i < lines.length && !/\}/.test(lines[i])) {
+          const p = lines[i].trim();
+          const ma = p.match(/^([\w_]+)\s*:\s*"?([^\"]+)"?/);
+          if (ma)
+            props[ma[1]] = ma[2];
+          else if (p)
+            props[p] = null;
+          i++;
+        }
+        if (i < lines.length && /\}/.test(lines[i]))
+          i++;
+      }
+      const obj = { type: "object", name, props };
+      ast.objects.push(obj);
+      ast.nodes.push(obj);
+      continue;
+    }
+    if (/^Φ\s+([\w_]+)\s*\{?/.test(line)) {
+      const m = line.match(/^Φ\s+([\w_]+)\s*\{?/);
+      const name = m ? m[1] : "form";
+      const props = {};
+      if (/\{$/.test(line)) {
+        i++;
+        while (i < lines.length && !/\}/.test(lines[i])) {
+          const p = lines[i].trim();
+          const ma = p.match(/^([\w_]+)\s*:\s*"?([^\"]+)"?/);
+          if (ma)
+            props[ma[1]] = ma[2];
+          else if (p)
+            props[p] = true;
+          i++;
+        }
+        if (i < lines.length && /\}/.test(lines[i]))
+          i++;
+      }
+      const form = { type: "form", name, props };
+      ast.forms.push(form);
+      ast.nodes.push(form);
+      continue;
+    }
+    if (/^Θ\s+animation\s+"([^"]+)"/.test(line)) {
+      const m = line.match(/^Θ\s+animation\s+"([^"]+)"/);
+      const name = m ? m[1] : "anim";
+      const props = {};
+      i++;
+      while (i < lines.length && !!lines[i].trim() && !/^Σ|^Δ|^Ψ|Ω|Φ|Λ|⊗/.test(lines[i].trim())) {
+        const p = lines[i].trim();
+        const ma = p.match(/^([\w_]+)\s*:\s*(.+)/);
+        if (ma)
+          props[ma[1]] = ma[2].trim();
+        i++;
+      }
+      const anim = { type: "animation", name, props };
+      ast.animations.push(anim);
+      ast.nodes.push(anim);
+      continue;
+    }
+    if (/^Λ\s+if\s+/.test(line)) {
+      const ruleLines = [];
+      let trueFlow = [];
+      let falseFlow = [];
+      let rule = line.replace(/^Λ\s+/, "");
+      i++;
+      while (i < lines.length && !!lines[i].trim() && !/^Σ|^Δ|^Ψ|Ω|Φ|Θ|⊗/.test(lines[i].trim())) {
+        const l = lines[i].trim();
+        if (/^else/i.test(l)) {
+          i++;
+          break;
+        }
+        if (/^→/.test(l))
+          trueFlow.push(l.replace(/^→\s?/, "").trim());
+        ruleLines.push(l);
+        i++;
+      }
+      while (i < lines.length && !!lines[i].trim() && !/^Σ|^Δ|^Ψ|Ω|Φ|Θ|⊗/.test(lines[i].trim())) {
+        const l = lines[i].trim();
+        if (/^→/.test(l))
+          falseFlow.push(l.replace(/^→\s?/, "").trim());
+        i++;
+      }
+      const logic = { type: "logic", rule, trueFlow, falseFlow };
+      ast.logic.push(logic);
+      ast.nodes.push(logic);
+      continue;
+    }
+    if (/^⊗\s*\{?/.test(line)) {
+      const items = [];
+      if (/\{$/.test(line)) {
+        i++;
+        while (i < lines.length && !/\}/.test(lines[i])) {
+          const l = lines[i].trim();
+          if (l)
+            items.push(l);
+          i++;
+        }
+        if (i < lines.length && /\}/.test(lines[i]))
+          i++;
+      }
+      const par = { type: "parallel", items };
+      ast.parallels.push(par);
+      ast.nodes.push(par);
+      continue;
+    }
+    i++;
+  }
+  return ast;
+}
+
+// src/runENY.ts
+function runENY(code, options) {
+  const hasSystem = /Σ\s+SYSTEM/i.test(code);
+  if (!hasSystem) {
+    if (options?.onLog) {
+      options.onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "warn", event: "runENY.no-system", detail: { length: code.length } });
+    }
+    return { raw: code, isEny: false, logs: [] };
+  }
+  const ast = parse(code, options);
+  ast.isEny = true;
+  return ast;
+}
+
+export {
+  runENY
+};