enyosx-ai 0.1.0

package/dist/chunk-GAKKLY4M.js

@@ -0,0 +1,276 @@
+// src/parser.ts
+function parse(code) {
+  const ast = {
+    raw: code,
+    functions: [],
+    ias: [],
+    nodes: [],
+    modules: [],
+    objects: [],
+    forms: [],
+    animations: [],
+    logic: [],
+    parallels: [],
+    build: null,
+    evolve: null,
+    targets: [],
+    version: null
+  };
+  const lines = code.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const raw = lines[i];
+    const line = raw.trim();
+    if (i % 10 === 0) {
+      console.log(`[parse] i=${i} line=${line.slice(0, 60)}`);
+    }
+    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, "");
+      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 = [];
+      i++;
+      while (i < lines.length) {
+        const l = lines[i];
+        if (!l.trim()) {
+          i++;
+          continue;
+        }
+        if (/^→/.test(l.trim()) || /^\s+→/.test(l) || /^\s+/.test(l)) {
+          steps.push({ raw: l.trim().replace(/^→\s?/, "") });
+          i++;
+        } else {
+          break;
+        }
+      }
+      const fn = { type: "function", name, args, steps };
+      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 };
+      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 };
+      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) {
+  return parse(code);
+}
+
+export {
+  runENY
+};

package/dist/chunk-HR4G5XQI.js

@@ -0,0 +1,319 @@
+// src/lexer/tokenize.ts
+var TokenType = /* @__PURE__ */ ((TokenType2) => {
+  TokenType2["SYMBOL"] = "SYMBOL";
+  TokenType2["IDENTIFIER"] = "IDENTIFIER";
+  TokenType2["STRING"] = "STRING";
+  TokenType2["NUMBER"] = "NUMBER";
+  TokenType2["ARROW"] = "ARROW";
+  TokenType2["LBRACE"] = "LBRACE";
+  TokenType2["RBRACE"] = "RBRACE";
+  TokenType2["COLON"] = "COLON";
+  TokenType2["COMMA"] = "COMMA";
+  TokenType2["LPAREN"] = "LPAREN";
+  TokenType2["RPAREN"] = "RPAREN";
+  TokenType2["NEWLINE"] = "NEWLINE";
+  TokenType2["COMPARATOR"] = "COMPARATOR";
+  TokenType2["EOF"] = "EOF";
+  return TokenType2;
+})(TokenType || {});
+var SYMBOLS = /* @__PURE__ */ new Set(["\u03A3", "\u0394", "\u03A8", "\u03A9", "\u03A6", "\u0398", "\u039B", "\u2301", "\u2297"]);
+function isWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\r";
+}
+function isNewline(ch) {
+  return ch === "\n";
+}
+function isDigit(ch) {
+  return /[0-9]/.test(ch);
+}
+function isIdentifierStart(ch) {
+  return /[A-Za-z_\p{L}]/u.test(ch);
+}
+function isIdentifierPart(ch) {
+  return /[A-Za-z0-9_\p{L}]/u.test(ch);
+}
+function tokenize(input) {
+  const tokens = [];
+  const len = input.length;
+  let i = 0;
+  while (i < len) {
+    const ch = input[i];
+    if (isWhitespace(ch)) {
+      i++;
+      continue;
+    }
+    if (isNewline(ch)) {
+      tokens.push({ type: "NEWLINE" /* NEWLINE */, value: "\n", pos: i });
+      i++;
+      continue;
+    }
+    if (SYMBOLS.has(ch)) {
+      tokens.push({ type: "SYMBOL" /* SYMBOL */, value: ch, pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "\u2192" || ch === "-" && input[i + 1] === ">") {
+      if (ch === "\u2192") {
+        tokens.push({ type: "ARROW" /* ARROW */, value: "\u2192", pos: i });
+        i++;
+      } else {
+        tokens.push({ type: "ARROW" /* ARROW */, value: "->", pos: i });
+        i += 2;
+      }
+      continue;
+    }
+    if (ch === "{") {
+      tokens.push({ type: "LBRACE" /* LBRACE */, value: "{", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "}") {
+      tokens.push({ type: "RBRACE" /* RBRACE */, value: "}", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      tokens.push({ type: "LPAREN" /* LPAREN */, value: "(", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      tokens.push({ type: "RPAREN" /* RPAREN */, value: ")", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === ":") {
+      tokens.push({ type: "COLON" /* COLON */, value: ":", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === ",") {
+      tokens.push({ type: "COMMA" /* COMMA */, value: ",", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "=" && input[i + 1] === "=" || ch === "!" && input[i + 1] === "=" || ch === ">" && input[i + 1] === "=" || ch === "<" && input[i + 1] === "=") {
+      tokens.push({ type: "COMPARATOR" /* COMPARATOR */, value: input.substr(i, 2), pos: i });
+      i += 2;
+      continue;
+    }
+    if (ch === ">" || ch === "<") {
+      tokens.push({ type: "COMPARATOR" /* COMPARATOR */, value: ch, pos: i });
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      let j = i + 1;
+      let out = "";
+      while (j < len) {
+        if (input[j] === "\\" && j + 1 < len) {
+          out += input[j + 1];
+          j += 2;
+          continue;
+        }
+        if (input[j] === '"') {
+          break;
+        }
+        out += input[j];
+        j++;
+      }
+      tokens.push({ type: "STRING" /* STRING */, value: out, pos: i });
+      i = j + 1;
+      continue;
+    }
+    if (isDigit(ch)) {
+      let j = i;
+      let val = "";
+      while (j < len && isDigit(input[j])) {
+        val += input[j];
+        j++;
+      }
+      tokens.push({ type: "NUMBER" /* NUMBER */, value: val, pos: i });
+      i = j;
+      continue;
+    }
+    if (isIdentifierStart(ch)) {
+      let j = i;
+      let val = "";
+      while (j < len && isIdentifierPart(input[j])) {
+        val += input[j];
+        j++;
+      }
+      tokens.push({ type: "IDENTIFIER" /* IDENTIFIER */, value: val, pos: i });
+      i = j;
+      continue;
+    }
+    tokens.push({ type: "IDENTIFIER" /* IDENTIFIER */, value: ch, pos: i });
+    i++;
+  }
+  tokens.push({ type: "EOF" /* EOF */, value: "", pos: i });
+  return tokens;
+}
+
+// src/parser/ebnfParser.ts
+function peek(cx) {
+  return cx.tokens[cx.i];
+}
+function next(cx) {
+  return cx.tokens[cx.i++];
+}
+function eat(cx, type, value) {
+  const t = peek(cx);
+  if (!t)
+    throw new Error(`Unexpected EOF, expected ${type}`);
+  if (t.type !== type)
+    throw new Error(`Expected token ${type} but got ${t.type} ('${t.value}') at ${t.pos}`);
+  if (value !== void 0 && t.value !== value)
+    throw new Error(`Expected token value ${value} but got '${t.value}' at ${t.pos}`);
+  return next(cx);
+}
+function skipNewlines(cx) {
+  while (peek(cx) && peek(cx).type === "NEWLINE" /* NEWLINE */)
+    next(cx);
+}
+function parseTokens(tokens, options) {
+  const cx = { tokens, i: 0 };
+  const ast = {
+    raw: tokens.map((t) => t.value).join(" "),
+    functions: [],
+    ias: [],
+    nodes: [],
+    modules: [],
+    objects: [],
+    forms: [],
+    animations: [],
+    logic: [],
+    parallels: [],
+    build: null,
+    evolve: null,
+    targets: [],
+    version: null,
+    logs: []
+  };
+  const onLog = (e) => {
+    const entry = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...e };
+    ast.logs.push(entry);
+    if (options?.onLog)
+      options.onLog(entry);
+  };
+  skipNewlines(cx);
+  while (peek(cx) && peek(cx).type !== "EOF" /* EOF */) {
+    const t = peek(cx);
+    if (t.type === "SYMBOL" /* SYMBOL */) {
+      const sym = t.value;
+      next(cx);
+      skipNewlines(cx);
+      const ident = peek(cx);
+      if (!ident)
+        break;
+      if (ident.type === "IDENTIFIER" /* IDENTIFIER */ && ident.value.toUpperCase() === "SYSTEM") {
+        next(cx);
+        const nameTok = eat(cx, "STRING" /* STRING */);
+        ast.system = nameTok.value;
+        onLog({ level: "info", event: "parse.system", detail: { name: ast.system } });
+        skipNewlines(cx);
+        continue;
+      }
+      if (ident.type === "IDENTIFIER" /* IDENTIFIER */ && ident.value.toUpperCase() === "MODULE") {
+        next(cx);
+        const nameTok = eat(cx, "STRING" /* STRING */);
+        const module = { type: "module", name: nameTok.value };
+        ast.modules.push(module);
+        ast.nodes.push(module);
+        onLog({ level: "info", event: "parse.module", detail: module });
+        skipNewlines(cx);
+        continue;
+      }
+      if (ident.type === "IDENTIFIER" /* IDENTIFIER */ && ident.value.toUpperCase() === "BUILD") {
+        next(cx);
+        eat(cx, "LBRACE" /* LBRACE */);
+        const targets = [];
+        while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+          const key = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+          eat(cx, "COLON" /* COLON */);
+          const val = peek(cx);
+          if (val.type === "IDENTIFIER" /* IDENTIFIER */ || val.type === "STRING" /* STRING */) {
+            targets.push(val.value);
+            next(cx);
+          } else {
+            throw new Error("Expected identifier or string for build target");
+          }
+          if (peek(cx) && peek(cx).type === "COMMA" /* COMMA */)
+            next(cx);
+        }
+        eat(cx, "RBRACE" /* RBRACE */);
+        const b = { type: "build", targets };
+        ast.build = b;
+        ast.nodes.push(b);
+        onLog({ level: "info", event: "parse.build", detail: b });
+        skipNewlines(cx);
+        continue;
+      }
+      skipNewlines(cx);
+      continue;
+    }
+    if (t.type === "SYMBOL" /* SYMBOL */ && t.value === "\u0394") {
+      next(cx);
+    }
+    if (t.type === "IDENTIFIER" /* IDENTIFIER */ && t.value.toLowerCase() === "\u0394") {
+      next(cx);
+      continue;
+    }
+    if (t.type === "IDENTIFIER" /* IDENTIFIER */) {
+      const val = t.value.toLowerCase();
+      next(cx);
+      skipNewlines(cx);
+      continue;
+    }
+    next(cx);
+    skipNewlines(cx);
+  }
+  return ast;
+}
+function parseFromCode(code, options) {
+  const tokens = tokenize(code);
+  return parseTokens(tokens, options);
+}
+
+// src/parser.ts
+async function writeWithRetry(entry, filePath, attempts = 3, delay = 1e3, onLog) {
+  const fsPromises = await import("fs/promises");
+  let attempt = 0;
+  const tryWrite = async () => {
+    attempt++;
+    try {
+      await fsPromises.appendFile(filePath, JSON.stringify(entry) + "\n", { encoding: "utf8" });
+      if (onLog)
+        onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "logfile.write.success", detail: { file: filePath } });
+      return;
+    } catch (err) {
+      const errEntry = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "warn", event: "logfile.write.retry", detail: { attempt, error: String(err) } };
+      if (onLog)
+        onLog(errEntry);
+      if (attempt < attempts) {
+        setTimeout(() => {
+          tryWrite().catch(() => {
+          });
+        }, delay);
+      } else {
+        const fatal = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "error", event: "logfile.write.fatal", detail: { attempt, error: String(err) } };
+        if (onLog)
+          onLog(fatal);
+      }
+    }
+  };
+  tryWrite().catch(() => {
+  });
+}
+function parse(code, options) {
+  const ast = parseFromCode(code, options);
+  ast.logs = ast.logs || [];
+  return ast;
+}
+
+export {
+  TokenType,
+  tokenize,
+  writeWithRetry,
+  parse
+};

package/dist/chunk-HROGCEE5.js

@@ -0,0 +1,30 @@
+import {
+  parse
+} from "./chunk-HR4G5XQI.js";
+
+// 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 } });
+    }
+    if (options?.logFile) {
+      const attempts = options?.logRetryAttempts ?? 3;
+      const delay = options?.logRetryDelayMs ?? 1e3;
+      import("./parser-4JXKOWKY.js").then((mod) => {
+        mod.writeWithRetry({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "warn", event: "runENY.no-system", detail: { length: code.length } }, options.logFile, attempts, delay, options?.onLog).catch(() => {
+        });
+      }).catch(() => {
+      });
+    }
+    return { raw: code, isEny: false, logs: [] };
+  }
+  const ast = parse(code, options);
+  ast.isEny = true;
+  return ast;
+}
+
+export {
+  runENY
+};

package/dist/chunk-MMH7M7MG.js

@@ -0,0 +1,30 @@
+import {
+  parse
+} from "./chunk-2WM5L76D.js";
+
+// 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 } });
+    }
+    if (options?.logFile) {
+      const attempts = options?.logRetryAttempts ?? 3;
+      const delay = options?.logRetryDelayMs ?? 1e3;
+      import("./parser-UUB6D2CZ.js").then((mod) => {
+        mod.writeWithRetry({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "warn", event: "runENY.no-system", detail: { length: code.length } }, options.logFile, attempts, delay, options?.onLog).catch(() => {
+        });
+      }).catch(() => {
+      });
+    }
+    return { raw: code, isEny: false, logs: [] };
+  }
+  const ast = parse(code, options);
+  ast.isEny = true;
+  return ast;
+}
+
+export {
+  runENY
+};