botql 1.0.1 → 1.1.2

package/botql.browser.js

@@ -0,0 +1,1335 @@
+"use strict";
+var BotQL = (() => {
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined") return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    try {
+      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    } catch (e) {
+      throw mod = 0, e;
+    }
+  };
+
+  // Parser.js
+  var require_Parser = __commonJS({
+    "Parser.js"(exports, module) {
+      "use strict";
+      var TokenType = { KEYWORD: "KEYWORD", STRING: "STRING", NUMBER: "NUMBER", IDENT: "IDENT", SYMBOL: "SYMBOL", EOF: "EOF" };
+      var KEYWORDS = /* @__PURE__ */ new Set(["CREATE", "BOT", "PLATFORM", "CONNECT", "TABLE", "PREVENT", "DEFAULT", "ON", "START", "MESSAGE", "FROM", "WHEN", "CONTAINS", "OR", "OTHERWISE", "KEYWORDS", "THINK", "WAITING", "REPLY", "TO", "FORWARD", "PARSE", "SEND", "INSERT", "INTO", "VALUES", "UPDATE", "SET", "WHERE", "RUN", "IMPORT", "AS", "RESPONSE"]);
+      var Token = class {
+        constructor(e, t, s) {
+          this.type = e, this.value = t, this.line = s;
+        }
+      };
+      var Tokenizer = class {
+        constructor(e) {
+          this.source = e, this.pos = 0, this.line = 1, this.tokens = [];
+        }
+        error(e) {
+          throw Error(`syntax error: ${e}`);
+        }
+        peekChar(e = 0) {
+          return this.source[this.pos + e];
+        }
+        tokenize() {
+          for (; this.pos < this.source.length; ) {
+            let e = this.peekChar();
+            if ("\n" === e) {
+              this.line++, this.pos++;
+              continue;
+            }
+            if (/\s/.test(e)) {
+              this.pos++;
+              continue;
+            }
+            if ("-" === e && "-" === this.peekChar(1)) {
+              for (; this.pos < this.source.length && "\n" !== this.peekChar(); ) this.pos++;
+              continue;
+            }
+            if ('"' === e || "'" === e) {
+              this.tokens.push(this.readString(e));
+              continue;
+            }
+            if (/[0-9]/.test(e)) {
+              this.tokens.push(this.readNumber());
+              continue;
+            }
+            if ("{}(),.=+*;".includes(e)) {
+              this.tokens.push(new Token(TokenType.SYMBOL, e, this.line)), this.pos++;
+              continue;
+            }
+            if (/[A-Za-z_]/.test(e)) {
+              let t = this.readWord();
+              this.tokens.push(t);
+              continue;
+            }
+            this.error(`unexpected character: "${e}"`);
+          }
+          return this.tokens.push(new Token(TokenType.EOF, null, this.line)), this.tokens;
+        }
+        readString(e) {
+          let t = this.line;
+          this.pos++;
+          let s = "";
+          for (; this.pos < this.source.length && this.peekChar() !== e; ) {
+            if ("\\" === this.peekChar()) {
+              this.pos++, s += this.peekChar(), this.pos++;
+              continue;
+            }
+            "\n" === this.peekChar() && this.line++, s += this.peekChar(), this.pos++;
+          }
+          return this.peekChar() !== e && this.error("unterminated string"), this.pos++, new Token(TokenType.STRING, s, t);
+        }
+        readNumber() {
+          let e = this.line, t = "";
+          for (; this.pos < this.source.length && /[0-9.]/.test(this.peekChar()); ) t += this.peekChar(), this.pos++;
+          return new Token(TokenType.NUMBER, Number(t), e);
+        }
+        readWord() {
+          let e = this.line, t = "";
+          for (; this.pos < this.source.length && /[A-Za-z0-9_]/.test(this.peekChar()); ) t += this.peekChar(), this.pos++;
+          let s = t.toUpperCase();
+          return KEYWORDS.has(s) && t === s ? new Token(TokenType.KEYWORD, s, e) : new Token(TokenType.IDENT, t, e);
+        }
+      };
+      var Parser = class {
+        constructor(e) {
+          this.tokens = new Tokenizer(e).tokenize(), this.pos = 0;
+        }
+        error(e) {
+          let t = this.current();
+          throw Error(`syntax error: ${e}, near "${t ? t.value : "EOF"}"`);
+        }
+        current() {
+          return this.tokens[this.pos];
+        }
+        at(e, t) {
+          let s = this.current();
+          return s.type === e && (void 0 === t || s.value === t);
+        }
+        atKeyword(...e) {
+          return this.at(TokenType.KEYWORD) && e.includes(this.current().value);
+        }
+        atWord(...e) {
+          let t = this.current();
+          return (t.type === TokenType.KEYWORD || t.type === TokenType.IDENT) && e.includes(t.value);
+        }
+        advance() {
+          let e = this.current();
+          return e.type !== TokenType.EOF && this.pos++, e;
+        }
+        expect(e, t) {
+          return this.at(e, t) || this.error(`expected ${t || e}`), this.advance();
+        }
+        expectKeyword(e) {
+          return this.expect(TokenType.KEYWORD, e);
+        }
+        isAtEnd() {
+          return this.at(TokenType.EOF);
+        }
+        parseProgram() {
+          let e = [];
+          for (; !this.isAtEnd(); ) e.push(this.parseStatement());
+          return { type: "Program", body: e };
+        }
+        parseBody() {
+          if (this.at(TokenType.SYMBOL, "{")) {
+            this.advance();
+            let e = [];
+            for (; !this.at(TokenType.SYMBOL, "}"); ) this.isAtEnd() && this.error('unclosed block "{"'), e.push(this.parseStatement());
+            return this.advance(), e;
+          }
+          return [this.parseStatement()];
+        }
+        parseStatement() {
+          return this.atKeyword("CREATE") ? this.parseCreate() : this.atKeyword("PLATFORM") ? this.parsePlatform() : this.atKeyword("CONNECT") ? this.parseConnect() : this.atKeyword("ON") ? this.parseOn() : this.atKeyword("WHEN") ? this.parseWhen() : this.atKeyword("OTHERWISE") ? this.parseOtherwise() : this.atKeyword("REPLY") ? this.parseReply() : this.atKeyword("THINK") ? this.parseThink() : this.atKeyword("FORWARD") ? this.parseForward() : this.atKeyword("PARSE") ? this.parseParseSignal() : this.atKeyword("SEND") ? this.parseSend() : this.atKeyword("INSERT") ? this.parseInsert() : this.atKeyword("UPDATE") ? this.parseUpdate() : this.atKeyword("RUN") ? this.parseRunBot() : this.atKeyword("IMPORT") ? this.parseImport() : void this.error("unexpected statement");
+        }
+        parseCreate() {
+          if (this.expectKeyword("CREATE"), this.atKeyword("BOT")) {
+            this.advance();
+            let e = this.expect(TokenType.STRING).value;
+            return { type: "CreateBot", name: e };
+          }
+          if (this.atKeyword("TABLE")) {
+            this.advance();
+            let t = this.expect(TokenType.IDENT).value, s = this.parseColumnList(), r = this.tryParsePreventDefault(), i = this.tryParseDefaultMessage();
+            return { type: "CreateTable", name: t, columns: s, preventDefault: r, defaultMessage: i };
+          }
+          this.error("expected BOT or TABLE after CREATE");
+        }
+        parseColumnList() {
+          this.expect(TokenType.SYMBOL, "(");
+          let e = [];
+          for (; !this.at(TokenType.SYMBOL, ")"); ) {
+            let t = this.expect(TokenType.IDENT).value, s = [], r = null;
+            for (; this.at(TokenType.IDENT) && !this.at(TokenType.SYMBOL, ",") && !this.at(TokenType.SYMBOL, ")"); ) {
+              let i = this.advance().value;
+              r ? s.push(i) : r = i;
+            }
+            e.push({ name: t, columnType: r, constraints: s }), this.at(TokenType.SYMBOL, ",") && this.advance();
+          }
+          return this.expect(TokenType.SYMBOL, ")"), e;
+        }
+        tryParsePreventDefault() {
+          return !!this.atKeyword("PREVENT") && (this.advance(), this.expectKeyword("DEFAULT"), true);
+        }
+        tryParseDefaultMessage() {
+          if (!this.atKeyword("DEFAULT")) return null;
+          let e = this.tokens[this.pos + 1];
+          if (!e || e.type !== TokenType.KEYWORD || "MESSAGE" !== e.value) return null;
+          if (this.advance(), this.advance(), this.isReplyFileForm()) {
+            this.expect(TokenType.SYMBOL, "(");
+            let t = this.parseFileName();
+            this.expect(TokenType.SYMBOL, ",");
+            let s = this.parseExpression();
+            return this.expect(TokenType.SYMBOL, ")"), { file: t, index: s };
+          }
+          let r = this.parseExpression();
+          return { value: r };
+        }
+        parsePlatform() {
+          this.expectKeyword("PLATFORM");
+          let e = this.advance().value;
+          return { type: "Platform", value: e };
+        }
+        parseConnect() {
+          if (this.expectKeyword("CONNECT"), this.atKeyword("RESPONSE")) {
+            this.advance();
+            let e = this.expect(TokenType.IDENT).value;
+            return { type: "ConnectResponse", alias: e };
+          }
+          let t = this.advance().value, s = this.advance().value, r = this.expect(TokenType.STRING).value;
+          return { type: "Connect", service: t, kind: s, credential: r };
+        }
+        parseOn() {
+          if (this.expectKeyword("ON"), this.atKeyword("START")) {
+            this.advance();
+            let e = this.parseBody();
+            return { type: "On", event: "START", body: e };
+          }
+          if (this.atKeyword("MESSAGE")) {
+            this.advance();
+            let t = this.parseBody();
+            return { type: "On", event: "MESSAGE", body: t };
+          }
+          if (this.atWord("SIGNAL")) {
+            this.advance(), this.expectKeyword("FROM");
+            let s = this.expect(TokenType.STRING).value, r = this.parseBody();
+            return { type: "On", event: "SIGNAL", source: s, body: r };
+          }
+          this.error("unexpected event after ON");
+        }
+        parseWhen() {
+          this.expectKeyword("WHEN");
+          let e = [this.parseCondition()];
+          for (; this.atKeyword("OR"); ) this.advance(), e.push(this.parseCondition());
+          let t = this.parseBody();
+          return { type: "When", conditions: e, body: t };
+        }
+        parseCondition() {
+          if (this.expectKeyword("CONTAINS"), this.at(TokenType.SYMBOL, "(")) {
+            let e = this.parseStringList();
+            return { op: "CONTAINS_ANY", values: e };
+          }
+          if (this.atKeyword("KEYWORDS")) {
+            this.advance(), this.expect(TokenType.SYMBOL, "(");
+            let t = this.parseFileName();
+            return this.expect(TokenType.SYMBOL, ")"), { op: "CONTAINS_KEYWORDS_FILE", path: t };
+          }
+          let s = this.expect(TokenType.STRING).value;
+          return { op: "CONTAINS", value: s };
+        }
+        parseStringList() {
+          this.expect(TokenType.SYMBOL, "(");
+          let e = [];
+          for (; !this.at(TokenType.SYMBOL, ")"); ) e.push(this.expect(TokenType.STRING).value), this.at(TokenType.SYMBOL, ",") && this.advance();
+          return this.expect(TokenType.SYMBOL, ")"), e;
+        }
+        parseFileName() {
+          let e = this.expect(TokenType.IDENT).value;
+          for (; this.at(TokenType.SYMBOL, "."); ) this.advance(), e += "." + this.expect(TokenType.IDENT).value;
+          return e;
+        }
+        parseOtherwise() {
+          this.expectKeyword("OTHERWISE");
+          let e = this.parseBody();
+          return { type: "Otherwise", body: e };
+        }
+        parseThink() {
+          this.expectKeyword("THINK"), this.expect(TokenType.SYMBOL, "(");
+          let e = this.parseFileName();
+          this.expect(TokenType.SYMBOL, ")");
+          let t = this.tryParseWaiting(), s = null;
+          return this.atKeyword("OR") && (this.advance(), s = this.parseReply()), { type: "Think", file: e, waiting: t, fallback: s };
+        }
+        tryParseWaiting() {
+          if (!this.atKeyword("WAITING")) return null;
+          this.advance(), this.expect(TokenType.SYMBOL, "(");
+          let e = null, t = null;
+          return !this.at(TokenType.SYMBOL, ")") && (e = this.parseFileName(), this.at(TokenType.SYMBOL, ",") && (this.advance(), t = this.parseExpression())), this.expect(TokenType.SYMBOL, ")"), { file: e, seconds: t };
+        }
+        parseReply() {
+          this.expectKeyword("REPLY");
+          let e = null;
+          if (this.atKeyword("TO") && (this.advance(), e = this.advance().value), this.isReplyFileForm()) {
+            this.expect(TokenType.SYMBOL, "(");
+            let t = this.parseFileName();
+            this.expect(TokenType.SYMBOL, ",");
+            let s = this.parseExpression();
+            return this.expect(TokenType.SYMBOL, ")"), { type: "Reply", target: e, file: t, index: s };
+          }
+          let r = this.parseExpression();
+          return { type: "Reply", target: e, value: r };
+        }
+        isReplyFileForm() {
+          if (!this.at(TokenType.SYMBOL, "(")) return false;
+          let e = this.tokens[this.pos + 1], t = this.tokens[this.pos + 2];
+          return !!e && e.type === TokenType.IDENT && !!t && t.type === TokenType.SYMBOL && "." === t.value;
+        }
+        parseForward() {
+          this.expectKeyword("FORWARD"), this.expectKeyword("TO");
+          let e = this.parseExpression();
+          return { type: "ForwardTo", target: e };
+        }
+        parseParseSignal() {
+          return this.expectKeyword("PARSE"), this.atWord("SIGNAL") || this.error("expected SIGNAL after PARSE"), this.advance(), { type: "ParseSignal" };
+        }
+        parseSend() {
+          this.expectKeyword("SEND"), this.expectKeyword("TO");
+          let e = this.advance().value;
+          return { type: "SendTo", target: e };
+        }
+        parseInsert() {
+          this.expectKeyword("INSERT"), this.expectKeyword("INTO");
+          let e = this.expect(TokenType.IDENT).value, t = null;
+          this.at(TokenType.SYMBOL, "(") && (t = this.parseExpressionList());
+          let s = null;
+          return this.atKeyword("VALUES") && (this.advance(), s = this.parseExpressionList()), { type: "Insert", table: e, columns: t, values: s };
+        }
+        parseExpressionList() {
+          this.expect(TokenType.SYMBOL, "(");
+          let e = [];
+          for (; !this.at(TokenType.SYMBOL, ")"); ) e.push(this.parseExpression()), this.at(TokenType.SYMBOL, ",") && this.advance();
+          return this.expect(TokenType.SYMBOL, ")"), e;
+        }
+        parseUpdate() {
+          this.expectKeyword("UPDATE");
+          let e = this.expect(TokenType.IDENT).value;
+          this.expectKeyword("SET");
+          let t = this.expect(TokenType.IDENT).value;
+          this.expect(TokenType.SYMBOL, "=");
+          let s = this.parseExpression(), r = null;
+          return this.atKeyword("WHERE") && (this.advance(), r = this.parseComparison()), { type: "Update", table: e, set: { column: t, value: s }, where: r };
+        }
+        parseImport() {
+          this.expectKeyword("IMPORT"), this.expect(TokenType.SYMBOL, "{");
+          let e = this.parseFileName(), t = null;
+          this.at(TokenType.SYMBOL, ",") && (this.advance(), t = this.parseExpression()), this.expect(TokenType.SYMBOL, "}");
+          let s = null;
+          return this.atKeyword("AS") && (this.advance(), s = this.expect(TokenType.IDENT).value), { type: "Import", path: e, index: t, alias: s };
+        }
+        parseRunBot() {
+          return this.expectKeyword("RUN"), this.expectKeyword("BOT"), { type: "RunBot" };
+        }
+        parseExpression() {
+          let e = this.parsePrimary();
+          for (; this.at(TokenType.SYMBOL, "+"); ) {
+            this.advance();
+            let t = this.parsePrimary();
+            e = { type: "Binary", op: "+", left: e, right: t };
+          }
+          return e;
+        }
+        parseComparison() {
+          let e = this.parseExpression();
+          if (this.at(TokenType.SYMBOL, "=")) {
+            this.advance();
+            let t = this.parseExpression();
+            return { type: "Binary", op: "=", left: e, right: t };
+          }
+          return e;
+        }
+        parsePrimary() {
+          let e = this.current();
+          if (e.type === TokenType.STRING || e.type === TokenType.NUMBER) return this.advance(), { type: "Literal", value: e.value };
+          if (e.type === TokenType.IDENT) {
+            this.advance();
+            let t = { type: "Identifier", name: e.value };
+            if (this.at(TokenType.SYMBOL, "(")) {
+              let s = this.parseExpressionList();
+              t = { type: "Call", callee: t.name, args: s };
+            }
+            for (; this.at(TokenType.SYMBOL, "."); ) {
+              this.advance();
+              let r = this.expect(TokenType.IDENT).value;
+              t = { type: "Member", object: t, property: r };
+            }
+            return t;
+          }
+          this.error("invalid expression");
+        }
+      };
+      module.exports = { Parser, Tokenizer, TokenType, KEYWORDS };
+    }
+  });
+
+  // Database.js
+  var require_Database = __commonJS({
+    "Database.js"(exports, module) {
+      "use strict";
+      var CONTEXT_SCHEMA = [{ name: "id", columnType: "INT", constraints: ["PRIMARY", "KEY", "AUTO_INCREMENT"] }, { name: "client", columnType: "TEXT", constraints: [] }, { name: "message", columnType: "TEXT", constraints: [] }, { name: "reply", columnType: "TEXT", constraints: [] }, { name: "created_at", columnType: "DATETIME", constraints: [] }];
+      var MemoryDatabase = class {
+        constructor() {
+          this.tables = /* @__PURE__ */ new Map(), this.autoIncrement = /* @__PURE__ */ new Map();
+        }
+        createTable(e, t, r) {
+          let s = "Context" === e && 0 === t.length ? CONTEXT_SCHEMA : t;
+          if (this.tables.has(e)) {
+            if (r) return;
+            throw Error(`runtime error: table "${e}" already exists`);
+          }
+          this.tables.set(e, { columns: s, rows: [] }), this.autoIncrement.set(e, 0);
+        }
+        insert(e, t, r) {
+          let s = this.tables.get(e);
+          if (!s) throw Error(`runtime error: table "${e}" does not exist`);
+          let n = this.autoIncrement.get(e) + 1;
+          this.autoIncrement.set(e, n);
+          let i = { id: n };
+          return t.forEach((e2, t2) => {
+            i[e2] = r[t2];
+          }), s.rows.push(i), n;
+        }
+        update(e, t, r, s, n) {
+          let i = this.tables.get(e);
+          if (!i) throw Error(`runtime error: table "${e}" does not exist`);
+          let a = s ? i.rows.find((e2) => e2[s] === n) : i.rows[i.rows.length - 1];
+          return a && (a[t] = r), a || null;
+        }
+        getRows(e) {
+          let t = this.tables.get(e);
+          return t ? t.rows.slice() : [];
+        }
+      };
+      function mapColumnType(e) {
+        let t = (e || "").toUpperCase();
+        return "INT" === t || "INTEGER" === t ? "INTEGER" : "TEXT";
+      }
+      function buildColumnDef(e) {
+        let t = mapColumnType(e.columnType), r = e.constraints.includes("PRIMARY") && e.constraints.includes("KEY"), s = e.constraints.includes("AUTO_INCREMENT"), n = `${e.name} ${t}`;
+        return r && (n += " PRIMARY KEY"), r && s && (n += " AUTOINCREMENT"), n;
+      }
+      var SQLiteDatabase = class {
+        constructor(e = ":memory:") {
+          let { DatabaseSync: t } = __require("node:sqlite");
+          this.driver = new t(e);
+        }
+        createTable(e, t, r) {
+          let s = "Context" === e && 0 === t.length ? CONTEXT_SCHEMA : t, n = s.map(buildColumnDef).join(", ");
+          this.driver.exec(`CREATE TABLE ${r ? "IF NOT EXISTS " : ""}${e} (${n})`);
+        }
+        insert(e, t, r) {
+          let s = t.map(() => "?").join(", "), n = `INSERT INTO ${e} (${t.join(", ")}) VALUES (${s})`, i = this.driver.prepare(n).run(...r);
+          return Number(i.lastInsertRowid);
+        }
+        update(e, t, r, s, n) {
+          if (s) {
+            let i = `UPDATE ${e} SET ${t} = ? WHERE ${s} = ?`;
+            this.driver.prepare(i).run(r, n);
+          } else {
+            let a = `UPDATE ${e} SET ${t} = ? WHERE id = (SELECT MAX(id) FROM ${e})`;
+            this.driver.prepare(a).run(r);
+          }
+        }
+        getRows(e) {
+          return this.driver.prepare(`SELECT * FROM ${e}`).all();
+        }
+        close() {
+          this.driver.close();
+        }
+      };
+      module.exports = { MemoryDatabase, SQLiteDatabase };
+    }
+  });
+
+  // FileSystem.js
+  var require_FileSystem = __commonJS({
+    "FileSystem.js"(exports, module) {
+      "use strict";
+      var MemoryFileSystem = class {
+        constructor(files = {}) {
+          this.files = new Map(
+            Object.entries(files).map(([k, v]) => [this._normalize(k), v])
+          );
+        }
+        _normalize(p) {
+          return String(p).replace(/^\.\//, "").replace(/\/+/g, "/").trim();
+        }
+        setFile(path, content) {
+          this.files.set(this._normalize(path), content);
+        }
+        exists(path) {
+          return this.files.has(this._normalize(path));
+        }
+        readFile(path) {
+          const key = this._normalize(path);
+          if (!this.files.has(key)) {
+            throw new Error(`BotQL: ficheiro n\xE3o encontrado: "${path}"`);
+          }
+          return this.files.get(key);
+        }
+        // basePath e' ignorado de proposito: no browser nao ha nocao real de
+        // diretorio corrente, os ficheiros importados sao identificados pelo
+        // nome/caminho tal como o utilizador os registou.
+        resolve(basePath, relativePath) {
+          return this._normalize(relativePath);
+        }
+        dirname(filePath) {
+          const norm = this._normalize(filePath);
+          const idx = norm.lastIndexOf("/");
+          return idx === -1 ? "" : norm.slice(0, idx);
+        }
+      };
+      var NodeFileSystem = class {
+        constructor() {
+          this._fs = __require("fs");
+          this._path = __require("path");
+        }
+        exists(path) {
+          return this._fs.existsSync(path);
+        }
+        readFile(path) {
+          return this._fs.readFileSync(path, "utf8");
+        }
+        resolve(basePath, relativePath) {
+          return this._path.resolve(basePath, relativePath);
+        }
+        dirname(filePath) {
+          return this._path.dirname(filePath);
+        }
+      };
+      var isNode = typeof process !== "undefined" && process.versions && !!process.versions.node;
+      function createDefaultFileSystem() {
+        return isNode ? new NodeFileSystem() : new MemoryFileSystem();
+      }
+      var api = { MemoryFileSystem, NodeFileSystem, createDefaultFileSystem };
+      if (typeof module !== "undefined" && module.exports) {
+        module.exports = api;
+      } else {
+        exports.BotQLFileSystem = api;
+      }
+    }
+  });
+
+  // RAG.js
+  var require_RAG = __commonJS({
+    "RAG.js"(exports, module) {
+      "use strict";
+      var STOPWORDS = /* @__PURE__ */ new Set([
+        "a",
+        "o",
+        "as",
+        "os",
+        "de",
+        "da",
+        "do",
+        "das",
+        "dos",
+        "e",
+        "ou",
+        "que",
+        "um",
+        "uma",
+        "uns",
+        "umas",
+        "em",
+        "no",
+        "na",
+        "nos",
+        "nas",
+        "por",
+        "para",
+        "com",
+        "sem",
+        "se",
+        "foi",
+        "ser",
+        "sao",
+        "esta",
+        "estao",
+        "ao",
+        "aos",
+        "mas",
+        "como",
+        "tem",
+        "ter",
+        "nao",
+        "sim",
+        "meu",
+        "minha",
+        "seu",
+        "sua",
+        "eu",
+        "tu",
+        "ele",
+        "ela",
+        "nos",
+        "vos",
+        "eles",
+        "elas",
+        "isso",
+        "isto",
+        "aquilo",
+        "quando",
+        "onde",
+        "porque",
+        "qual",
+        "quais",
+        "muito",
+        "muita",
+        "ja",
+        "so"
+      ]);
+      function normalizar(texto) {
+        return texto.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+      }
+      var SUFIXOS_ADJETIVO_ADVERBIO = ["issimamente", "issimo", "issima", "mente"];
+      var SUFIXOS_NOMINALIZACAO = ["acoes", "acao", "imentos", "imento", "idades", "idade"];
+      function stem(palavra) {
+        let p = palavra;
+        for (const suf of SUFIXOS_ADJETIVO_ADVERBIO) {
+          if (p.length > suf.length + 3 && p.endsWith(suf)) {
+            p = p.slice(0, -suf.length);
+            break;
+          }
+        }
+        for (const suf of SUFIXOS_NOMINALIZACAO) {
+          if (p.length > suf.length + 3 && p.endsWith(suf)) {
+            p = p.slice(0, -suf.length);
+            break;
+          }
+        }
+        if (p.length > 4 && p.endsWith("s") && !p.endsWith("ns")) {
+          p = p.slice(0, -1);
+        }
+        return p;
+      }
+      function tokenizar(texto) {
+        return normalizar(texto).toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((palavra) => palavra.length > 1 && !STOPWORDS.has(palavra)).map(stem);
+      }
+      function distanciaEdicao(a, b) {
+        if (a === b) return 0;
+        const la = a.length;
+        const lb = b.length;
+        if (la === 0) return lb;
+        if (lb === 0) return la;
+        let linhaAnterior = new Array(lb + 1);
+        for (let j = 0; j <= lb; j++) linhaAnterior[j] = j;
+        for (let i = 1; i <= la; i++) {
+          const linhaAtual = [i];
+          for (let j = 1; j <= lb; j++) {
+            const custo = a[i - 1] === b[j - 1] ? 0 : 1;
+            linhaAtual[j] = Math.min(
+              linhaAtual[j - 1] + 1,
+              linhaAnterior[j] + 1,
+              linhaAnterior[j - 1] + custo
+            );
+          }
+          linhaAnterior = linhaAtual;
+        }
+        return linhaAnterior[lb];
+      }
+      function distanciaMaximaTolerada(tamanho) {
+        if (tamanho <= 4) return 0;
+        if (tamanho <= 7) return 1;
+        return 2;
+      }
+      var BM25_K1 = 1.5;
+      var BM25_B = 0.75;
+      var PESO_BM25 = 1;
+      var PESO_FRASE = 2.5;
+      var PESO_FUZZY = 0.4;
+      var CONFIANCA_ALTA = 0.55;
+      var CONFIANCA_MINIMA = 0.15;
+      var MARGEM_MINIMA = 0.12;
+      var SIMILARIDADE_DUPLICADA = 0.75;
+      function extrairNomesProprios(texto) {
+        const palavras = texto.split(/\s+/);
+        const encontrados = [];
+        for (let i = 1; i < palavras.length; i++) {
+          const limpa = palavras[i].replace(/^[(["']+|[.,;:!?)\]"']+$/g, "");
+          if (/^[A-ZÀ-Ý][a-zà-ÿ]+$/.test(limpa)) {
+            encontrados.push(limpa);
+          }
+        }
+        return encontrados;
+      }
+      var KnowledgeIndex = class _KnowledgeIndex {
+        /**
+        * @param {string} sourceText Conteúdo do ficheiro de conhecimento.
+        * @param {Object} [options]
+        * @param {Record<string,string>} [options.synonyms] Mapa de termo -> termo
+        *   canónico, para ligar manualmente palavras que o stemmer não junta
+        *   sozinho (ex: { horas: 'horario' }).
+        */
+        constructor(sourceText, options = {}) {
+          this.synonyms = {};
+          for (const [de, para] of Object.entries(options.synonyms || {})) {
+            this.synonyms[stem(normalizar(de.toLowerCase()))] = stem(normalizar(para.toLowerCase()));
+          }
+          this.blocks = _KnowledgeIndex.parseBlocks(sourceText);
+          this._buildIndex();
+        }
+        static parseBlocks(sourceText) {
+          return sourceText.split(/\n\s*\n/).map((bloco) => bloco.trim()).filter((bloco) => bloco.length > 0);
+        }
+        _aplicarSinonimos(tokens) {
+          return tokens.map((t) => this.synonyms[t] || t);
+        }
+        _buildIndex() {
+          this.docs = this.blocks.map((bloco) => tokenizar(bloco));
+          this.docTextNormalizado = this.blocks.map((bloco) => normalizar(bloco).toLowerCase());
+          this.docFreq = /* @__PURE__ */ new Map();
+          this.vocabulario = /* @__PURE__ */ new Set();
+          for (const tokens of this.docs) {
+            const vistas = new Set(tokens);
+            for (const palavra of vistas) {
+              this.docFreq.set(palavra, (this.docFreq.get(palavra) || 0) + 1);
+              this.vocabulario.add(palavra);
+            }
+          }
+          this.listaVocabulario = Array.from(this.vocabulario);
+          this.totalDocs = this.docs.length;
+          this.avgDocLen = this.totalDocs === 0 ? 0 : this.docs.reduce((soma, tokens) => soma + tokens.length, 0) / this.totalDocs;
+        }
+        _idf(palavra) {
+          const n = this.docFreq.get(palavra) || 0;
+          if (n === 0) return 0;
+          return Math.log(1 + (this.totalDocs - n + 0.5) / (n + 0.5));
+        }
+        _termoMaisProximo(termo) {
+          const tolerancia = distanciaMaximaTolerada(termo.length);
+          if (tolerancia === 0) return null;
+          let melhor = null;
+          let melhorDist = tolerancia + 1;
+          for (const candidato of this.listaVocabulario) {
+            if (Math.abs(candidato.length - termo.length) > tolerancia) continue;
+            const d = distanciaEdicao(termo, candidato);
+            if (d < melhorDist) {
+              melhorDist = d;
+              melhor = candidato;
+            }
+          }
+          return melhorDist <= tolerancia ? melhor : null;
+        }
+        _scoreBM25(queryTokens, docIndex) {
+          const tokens = this.docs[docIndex];
+          if (tokens.length === 0) return 0;
+          const termFreq = /* @__PURE__ */ new Map();
+          for (const t of tokens) termFreq.set(t, (termFreq.get(t) || 0) + 1);
+          let score = 0;
+          for (const termo of queryTokens) {
+            let tf = termFreq.get(termo) || 0;
+            let idf = this._idf(termo);
+            let peso = 1;
+            if (tf === 0) {
+              const proximo = this._termoMaisProximo(termo);
+              if (proximo === null) continue;
+              tf = termFreq.get(proximo) || 0;
+              if (tf === 0) continue;
+              idf = this._idf(proximo);
+              peso = PESO_FUZZY;
+            }
+            const numerador = tf * (BM25_K1 + 1);
+            const denominador = tf + BM25_K1 * (1 - BM25_B + BM25_B * (tokens.length / this.avgDocLen));
+            score += peso * idf * (numerador / denominador);
+          }
+          return score;
+        }
+        _bonusFrase(message, docIndex) {
+          const msgNorm = normalizar(message).toLowerCase().replace(/[^a-z0-9\s]/g, " ");
+          const palavras = msgNorm.split(/\s+/).filter((p) => p.length > 1);
+          if (palavras.length < 2) return 0;
+          const textoBloco = this.docTextNormalizado[docIndex];
+          let bonus = 0;
+          for (let tamanho = Math.min(6, palavras.length); tamanho >= 2; tamanho--) {
+            for (let i = 0; i + tamanho <= palavras.length; i++) {
+              const frase = palavras.slice(i, i + tamanho).join(" ");
+              if (textoBloco.includes(frase)) {
+                bonus += tamanho * tamanho;
+              }
+            }
+          }
+          return bonus;
+        }
+        _scoreDoc(message, queryTokens, docIndex) {
+          const bm25 = this._scoreBM25(queryTokens, docIndex);
+          const frase = this._bonusFrase(message, docIndex);
+          return PESO_BM25 * bm25 + PESO_FRASE * frase;
+        }
+        // Calcula o score de todos os blocos para a mensagem e devolve ordenado
+        // do maior para o menor. Base partilhada por search() e analyze().
+        _rankTodos(message) {
+          const queryTokens = this._aplicarSinonimos(tokenizar(message));
+          if (queryTokens.length === 0) return [];
+          const resultados = [];
+          for (let i = 0; i < this.totalDocs; i++) {
+            resultados.push({ index: i, score: this._scoreDoc(message, queryTokens, i) });
+          }
+          resultados.sort((a, b) => b.score - a.score);
+          return resultados;
+        }
+        /**
+        * Procura o bloco mais relevante para a mensagem recebida.
+        *
+        * @returns {{text: string, score: number, confidence: number, index: number} | null}
+        *   `confidence` está sempre entre 0 e 1 — não é probabilidade
+        *   estatística real, é uma escala interpretável para decidir um
+        *   limiar no `.sql` (ex: "só responde se confidence > 0.3").
+        */
+        search(message) {
+          if (this.totalDocs === 0) return null;
+          const ranking = this._rankTodos(message);
+          if (ranking.length === 0) return null;
+          const melhor = ranking[0];
+          if (melhor.score <= 0) return null;
+          return {
+            text: this.blocks[melhor.index],
+            score: melhor.score,
+            confidence: melhor.score / (melhor.score + 3),
+            index: melhor.index
+          };
+        }
+        // Jaccard sobre os tokens (já com stem aplicado) de dois blocos já
+        // indexados. Usado só pra detetar "mesmo conteúdo repetido" (valor
+        // alto) — dois blocos sobre o mesmo assunto mas com detalhes
+        // diferentes normalmente NÃO têm jaccard alto (a maior parte da frase
+        // difere), por isso não serve pra decidir se vale a pena tentar unir.
+        _similaridadeBlocos(indexA, indexB) {
+          const a = new Set(this.docs[indexA]);
+          const b = new Set(this.docs[indexB]);
+          if (a.size === 0 || b.size === 0) return 0;
+          let intersecao = 0;
+          for (const t of a) if (b.has(t)) intersecao++;
+          const uniao = a.size + b.size - intersecao;
+          return uniao === 0 ? 0 : intersecao / uniao;
+        }
+        // Quantos tokens (com stem) os dois blocos partilham, em termos
+        // absolutos. Usado como gatilho pra tentar unir: basta partilharem UM
+        // termo de assunto ("entregamos") — quem garante que a fusão é segura
+        // não é isto, é a regra de "exatamente um nome próprio diferente em
+        // cada bloco" dentro de _tentarUnir.
+        _termosPartilhados(indexA, indexB) {
+          const a = new Set(this.docs[indexA]);
+          const b = this.docs[indexB];
+          let count = 0;
+          for (const t of b) if (a.has(t)) count++;
+          return count;
+        }
+        // Compara dois blocos concorrentes pelo nome próprio que cada um
+        // menciona, pra decidir se são "a mesma informação" ou "informação
+        // complementar que dá pra unir":
+        //   - mesmo nome próprio nos dois (ex: os dois falam de Luanda)
+        //     -> { tipo: 'duplicado' }: é a mesma coisa dita de formas
+        //     diferentes, não há o que unir, usa qualquer um dos dois
+        //   - nomes próprios diferentes (ex: Luanda vs Huambo)
+        //     -> { tipo: 'unido', texto: '...' }: funde numa frase só
+        //   - não dá pra identificar com segurança (nenhum nome próprio, ou
+        //     mais de um em algum dos blocos) -> null: quem chama decide o
+        //     que fazer a seguir (normalmente: reanalisar, ou cair no fallback)
+        _tentarUnir(textoA, textoB) {
+          const entidadesA = extrairNomesProprios(textoA);
+          const entidadesB = extrairNomesProprios(textoB);
+          if (entidadesA.length !== 1 || entidadesB.length !== 1) return null;
+          const entidadeA = entidadesA[0];
+          const entidadeB = entidadesB[0];
+          if (normalizar(entidadeA).toLowerCase() === normalizar(entidadeB).toLowerCase()) {
+            return { tipo: "duplicado" };
+          }
+          const primeiraPalavra = textoA.trim().split(/\s+/)[0].replace(/[.,;:!?]+$/, "");
+          return { tipo: "unido", texto: `${primeiraPalavra} em v\xE1rios lugares, como ${entidadeA} e ${entidadeB}.` };
+        }
+        // Segunda tentativa de ranking, usada só quando a primeira ficou
+        // ambígua: descarta metade dos termos da query (os de menor IDF, ou
+        // seja, os mais genéricos/comuns) e refaz o ranking só com os termos
+        // mais raros/decisivos. Uma query mais focada às vezes desempata o
+        // que uma query "cheia" deixa embolado.
+        _reanalisarFocado(message) {
+          const tokens = this._aplicarSinonimos(tokenizar(message));
+          if (tokens.length <= 2) return null;
+          const comIdf = tokens.map((t) => ({ termo: t, idf: this._idf(t) }));
+          comIdf.sort((a, b) => b.idf - a.idf);
+          const focados = comIdf.slice(0, Math.max(1, Math.ceil(tokens.length / 2))).map((x) => x.termo);
+          const resultados = [];
+          for (let i = 0; i < this.totalDocs; i++) {
+            resultados.push({ index: i, score: this._scoreDoc(message, focados, i) });
+          }
+          resultados.sort((a, b) => b.score - a.score);
+          return resultados;
+        }
+        /**
+        * Versão completa da busca: além do melhor bloco, avalia a evidência
+        * (melhor x segundo colocado) e devolve uma decisão explícita, em vez
+        * de deixar o `.sql` decidir tudo com um único limiar de confidence.
+        *
+        * EvidenceEvaluator: compara o melhor resultado com o segundo. Se os
+        * dois estão muito próximos, o motor não tem certeza de qual bloco
+        * responde à pergunta — mesmo que o score absoluto seja alto.
+        *
+        * ConfidenceEngine: mesma fórmula de sempre (score / (score + 3)),
+        * aplicada só ao melhor resultado.
+        *
+        * DecisionEngine: cruza confidence com margem para decidir entre:
+        *   - RESPONDER    confidence alta e o melhor bloco se destaca do 2o,
+        *                  OU os dois concorrentes foram reconciliados (ver
+        *                  abaixo) — nesse caso `texto` já vem pronto pra usar
+        *   - REANALISAR   os blocos concorrentes são sobre assuntos diferentes
+        *                  demais pra reconciliar, e nem a retentativa focada
+        *                  resolveu — o `.sql` decide o que fazer (normalmente
+        *                  cair no fallback do OR REPLY)
+        *   - UNKNOWN      confidence baixa demais, não há bloco que sirva
+        *
+        * Reconciliação (só entra quando o resultado não é decisivo de cara):
+        *   1. Se o melhor e o segundo colocado são basicamente o mesmo
+        *      conteúdo (alta similaridade) — não há nada pra unir, usa o
+        *      melhor tal como está.
+        *   2. Se são blocos diferentes mas do mesmo assunto, e cada um tem
+        *      exatamente um nome próprio diferente (ex: "entregamos em
+        *      Luanda" / "entregamos no Huambo") — tenta fundir numa frase só
+        *      ("entregamos em vários lugares, como Luanda e Huambo").
+        *   3. Se nada disso se aplica, tenta de novo com uma versão mais
+        *      enxuta da pergunta (só os termos mais decisivos) antes de
+        *      desistir.
+        *
+        * @returns {{
+        *   decision: 'RESPONDER'|'REANALISAR'|'UNKNOWN',
+        *   confidence: number,
+        *   margem: number,
+        *   texto: string | null,
+        *   unificado: boolean,
+        *   reanalisado: boolean,
+        *   melhor: {text: string, score: number, index: number} | null,
+        *   segundo: {text: string, score: number, index: number} | null
+        * }}
+        */
+        analyze(message) {
+          const vazio = { decision: "UNKNOWN", confidence: 0, margem: 0, texto: null, unificado: false, reanalisado: false, melhor: null, segundo: null };
+          if (this.totalDocs === 0) return vazio;
+          const ranking = this._rankTodos(message);
+          if (ranking.length === 0 || ranking[0].score <= 0) return vazio;
+          const melhor = ranking[0];
+          const segundo = ranking[1] || { index: -1, score: 0 };
+          const margem = (melhor.score - segundo.score) / melhor.score;
+          const confidence = melhor.score / (melhor.score + 3);
+          const melhorInfo = { text: this.blocks[melhor.index], score: melhor.score, index: melhor.index };
+          const segundoInfo = segundo.index >= 0 ? { text: this.blocks[segundo.index], score: segundo.score, index: segundo.index } : null;
+          if (confidence < CONFIANCA_MINIMA) return vazio;
+          if (confidence >= CONFIANCA_ALTA && margem >= MARGEM_MINIMA) {
+            return {
+              decision: "RESPONDER",
+              confidence,
+              margem,
+              texto: melhorInfo.text,
+              unificado: false,
+              reanalisado: false,
+              melhor: melhorInfo,
+              segundo: segundoInfo
+            };
+          }
+          if (segundoInfo) {
+            const similaridade = this._similaridadeBlocos(melhor.index, segundo.index);
+            if (similaridade >= SIMILARIDADE_DUPLICADA) {
+              return {
+                decision: "RESPONDER",
+                confidence,
+                margem,
+                texto: melhorInfo.text,
+                unificado: false,
+                reanalisado: false,
+                melhor: melhorInfo,
+                segundo: segundoInfo
+              };
+            }
+            const termosPartilhados = this._termosPartilhados(melhor.index, segundo.index);
+            if (termosPartilhados >= 1) {
+              const resultado = this._tentarUnir(melhorInfo.text, segundoInfo.text);
+              if (resultado && resultado.tipo === "duplicado") {
+                return {
+                  decision: "RESPONDER",
+                  confidence,
+                  margem,
+                  texto: melhorInfo.text,
+                  unificado: false,
+                  reanalisado: false,
+                  melhor: melhorInfo,
+                  segundo: segundoInfo
+                };
+              }
+              if (resultado && resultado.tipo === "unido") {
+                return {
+                  decision: "RESPONDER",
+                  confidence,
+                  margem,
+                  texto: resultado.texto,
+                  unificado: true,
+                  reanalisado: false,
+                  melhor: melhorInfo,
+                  segundo: segundoInfo
+                };
+              }
+            }
+          }
+          const tentativa2 = this._reanalisarFocado(message);
+          if (tentativa2 && tentativa2.length > 0 && tentativa2[0].score > 0) {
+            const melhor2 = tentativa2[0];
+            const segundo2 = tentativa2[1] || { index: -1, score: 0 };
+            const margem2 = (melhor2.score - segundo2.score) / melhor2.score;
+            const confidence2 = melhor2.score / (melhor2.score + 3);
+            if (confidence2 >= CONFIANCA_ALTA && margem2 >= MARGEM_MINIMA) {
+              return {
+                decision: "RESPONDER",
+                confidence: confidence2,
+                margem: margem2,
+                texto: this.blocks[melhor2.index],
+                unificado: false,
+                reanalisado: true,
+                melhor: { text: this.blocks[melhor2.index], score: melhor2.score, index: melhor2.index },
+                segundo: segundo2.index >= 0 ? { text: this.blocks[segundo2.index], score: segundo2.score, index: segundo2.index } : null
+              };
+            }
+          }
+          return {
+            decision: "REANALISAR",
+            confidence,
+            margem,
+            texto: null,
+            unificado: false,
+            reanalisado: false,
+            melhor: melhorInfo,
+            segundo: segundoInfo
+          };
+        }
+      };
+      var KnowledgeCache = class {
+        constructor(fileSystem) {
+          this.fileSystem = fileSystem;
+          this.cache = /* @__PURE__ */ new Map();
+        }
+        get(resolvedPath, options) {
+          if (this.cache.has(resolvedPath)) return this.cache.get(resolvedPath);
+          if (!this.fileSystem.exists(resolvedPath)) {
+            throw new Error(`BotQL/THINK: ficheiro de conhecimento n\xE3o encontrado: "${resolvedPath}"`);
+          }
+          const texto = this.fileSystem.readFile(resolvedPath);
+          const index = new KnowledgeIndex(texto, options);
+          this.cache.set(resolvedPath, index);
+          return index;
+        }
+      };
+      module.exports = { KnowledgeIndex, KnowledgeCache, tokenizar, normalizar, stem, distanciaEdicao };
+    }
+  });
+
+  // botql.js
+  var require_botql = __commonJS({
+    "botql.js"(exports, module) {
+      var { Parser: e } = require_Parser();
+      var { MemoryDatabase: t } = require_Database();
+      var { createDefaultFileSystem: s } = require_FileSystem();
+      var { KnowledgeCache: i } = require_RAG();
+      var WAITING_TEXTO_PADRAO = "Pensando...";
+      var BotQLInterpreter = class _BotQLInterpreter {
+        constructor(e2 = {}) {
+          this.db = e2.db || new t(), this.onReply = e2.onReply || null, this.onForward = e2.onForward || null, this.onSend = e2.onSend || null, this.signalParser = e2.signalParser || ((e3) => e3), this.onThinking = e2.onThinking || null, this.botName = null, this.platform = null, this.connections = [], this.handlers = { START: [], MESSAGE: [], SIGNAL: [] }, this.running = false, this.responseConnections = /* @__PURE__ */ new Set(), this.onResponse = e2.onResponse || null, this.defaultMessageConfig = null, this.nativeFuncs = /* @__PURE__ */ new Map(), this.registerFunction("NOW", () => (/* @__PURE__ */ new Date()).toISOString()), this.fileSystem = e2.fileSystem || s();
+          let n = "undefined" != typeof process && process.cwd ? process.cwd() : "";
+          this._basePathStack = [e2.basePath || n], this._importedFiles = /* @__PURE__ */ new Set(), this._rootBasePath = e2.basePath || n, this._keywordsFileCache = /* @__PURE__ */ new Map(), this._replyFileCache = /* @__PURE__ */ new Map(), this.envValues = /* @__PURE__ */ new Map(), this.knowledgeCache = new i(this.fileSystem);
+        }
+        static fromSource(t2, s2 = {}) {
+          let i2 = new e(t2).parseProgram(), n = new _BotQLInterpreter(s2);
+          return n.load(i2), n;
+        }
+        static fromFile(e2, t2 = {}) {
+          let i2 = t2.fileSystem || s(), n = i2.resolve("", e2), r = i2.readFile(n);
+          return _BotQLInterpreter.fromSource(r, { ...t2, fileSystem: i2, basePath: i2.dirname(n) });
+        }
+        registerFunction(e2, t2) {
+          this.nativeFuncs.set(e2, t2);
+        }
+        load(e2, t2 = this._basePathStack[this._basePathStack.length - 1]) {
+          let s2 = this._flattenImports(e2.body, t2);
+          for (let i2 of s2) switch (i2.type) {
+            case "CreateBot":
+              this.botName = i2.name;
+              break;
+            case "Platform":
+              this.platform = i2.value;
+              break;
+            case "Connect":
+              this.connections.push({ service: i2.service, kind: i2.kind, credential: i2.credential });
+              break;
+            case "ConnectResponse":
+              if (!this.envValues.has(i2.alias)) throw Error(`runtime error: CONNECT RESPONSE failed, alias "${i2.alias}" was not imported (use IMPORT {..., N} AS ${i2.alias})`);
+              this.responseConnections.add(i2.alias);
+              break;
+            case "CreateTable":
+              if (this.db.createTable(i2.name, i2.columns, i2.preventDefault), i2.defaultMessage) {
+                let n = "Context" === i2.name ? "client" : (i2.columns.find((e3) => "client" === e3.name || "sender" === e3.name) || {}).name;
+                if (!n) throw Error(`runtime error: DEFAULT MESSAGE on table "${i2.name}" requires a "client" or "sender" column`);
+                this.defaultMessageConfig = { table: i2.name, senderColumn: n, ...i2.defaultMessage };
+              }
+              break;
+            case "On":
+              this.handlers[i2.event].push(i2);
+              break;
+            case "RunBot":
+              this.running = true;
+              break;
+            default:
+              throw Error(`runtime error: unsupported top-level statement: ${i2.type}`);
+          }
+        }
+        _flattenImports(t2, s2) {
+          let i2 = [], n = [];
+          for (let r of t2) {
+            if ("Import" !== r.type) {
+              n.push(r);
+              continue;
+            }
+            if (null !== r.index && void 0 !== r.index) {
+              let a = this.evalExpr(r.index, this.createContext()), l = this._loadIndexedFile(r.path, s2), o = l.get(Number(a));
+              if (void 0 === o) throw Error(`runtime error: IMPORT failed, entry ${a} not found in "${r.path}"`);
+              let h = r.alias || r.path.replace(/\.[^.]+$/, "");
+              this.envValues.set(h, o);
+              continue;
+            }
+            let u = this.fileSystem.resolve(s2, r.path);
+            if (this._importedFiles.has(u)) continue;
+            if (!this.fileSystem.exists(u)) throw Error(`runtime error: IMPORT failed, file not found: "${u}"`);
+            this._importedFiles.add(u);
+            let c = this.fileSystem.readFile(u), f = new e(c).parseProgram(), d = this._flattenImports(f.body, this.fileSystem.dirname(u));
+            i2.push(...d);
+          }
+          return [...i2, ...n];
+        }
+        createContext(e2 = {}) {
+          return { vars: { client: e2.client || null, message: e2.message || null, lastMsg: null, SIGNAL: null }, rawSignal: e2.rawSignal || null, lastInsertId: null };
+        }
+        async start() {
+          for (let e2 of this.handlers.START) {
+            let t2 = this.createContext();
+            await this.run(e2.body, t2);
+          }
+        }
+        async receiveMessage(e2, t2) {
+          let s2 = this.createContext({ client: e2, message: t2 }), i2 = await this.greetIfNew(e2);
+          if (i2) return s2;
+          for (let n of this.handlers.MESSAGE) await this.run(n.body, s2);
+          return s2;
+        }
+        async greetIfNew(e2) {
+          if (!this.defaultMessageConfig) return false;
+          let { table: t2, senderColumn: s2 } = this.defaultMessageConfig, i2 = this.db.getRows(t2).some((t3) => t3[s2] === e2);
+          if (i2) return false;
+          let n = this.createContext({ client: e2 }), r = this.resolveDefaultMessageText(this.defaultMessageConfig, n);
+          return n.vars.lastMsg = r, this.db.insert(t2, [s2], [e2]), this.onReply && await this.onReply({ target: null, text: r, client: e2 }), true;
+        }
+        resolveDefaultMessageText(e2, t2) {
+          return e2.file ? this.resolveReplyFromFile(e2.file, e2.index, t2) : String(this.evalExpr(e2.value, t2));
+        }
+        async receiveSignal(e2, t2) {
+          let s2 = this.createContext({ rawSignal: t2 });
+          for (let i2 of this.handlers.SIGNAL) i2.source === e2 && await this.run(i2.body, s2);
+          return s2;
+        }
+        async run(e2, t2) {
+          let s2 = false;
+          for (let i2 = 0; i2 < e2.length; i2++) {
+            let n = e2[i2];
+            if ("When" === n.type) {
+              (0 === i2 || "When" !== e2[i2 - 1].type) && (s2 = false);
+              let r = n.conditions.some((e3) => this.evalCondition(e3, t2));
+              r && (await this.run(n.body, t2), s2 = true);
+              continue;
+            }
+            if ("Otherwise" === n.type) {
+              s2 || await this.run(n.body, t2), s2 = false;
+              continue;
+            }
+            await this.execStatement(n, t2);
+          }
+        }
+        evalCondition(e2, t2) {
+          if ("string" != typeof t2.vars.message) return false;
+          let s2 = t2.vars.message.toLowerCase();
+          if ("CONTAINS" === e2.op) return s2.includes(e2.value.toLowerCase());
+          if ("CONTAINS_ANY" === e2.op) return e2.values.some((e3) => s2.includes(e3.toLowerCase()));
+          if ("CONTAINS_KEYWORDS_FILE" === e2.op) {
+            let i2 = this._loadKeywordsFile(e2.path);
+            return i2.some((e3) => s2.includes(e3.toLowerCase()));
+          }
+          throw Error(`runtime error: unsupported condition: ${e2.op}`);
+        }
+        _loadKeywordsFile(e2) {
+          if (this._keywordsFileCache.has(e2)) return this._keywordsFileCache.get(e2);
+          let t2 = this.fileSystem.resolve(this._rootBasePath, e2);
+          if (!this.fileSystem.exists(t2)) throw Error(`runtime error: KEYWORDS failed, file not found: "${t2}"`);
+          let s2 = this.fileSystem.readFile(t2), i2 = s2.split("\n").map((e3) => e3.trim()).filter((e3) => e3.length > 0);
+          return this._keywordsFileCache.set(e2, i2), i2;
+        }
+        resolveWaitingConfig(e2, t2) {
+          if (!e2) return { text: WAITING_TEXTO_PADRAO, seconds: 3 };
+          let s2 = WAITING_TEXTO_PADRAO;
+          if (e2.file) {
+            let i2 = this.fileSystem.resolve(this._rootBasePath, e2.file);
+            if (!this.fileSystem.exists(i2)) throw Error(`runtime error: WAITING failed, file not found: "${i2}"`);
+            s2 = this.fileSystem.readFile(i2).trim();
+          }
+          let n = 3;
+          return e2.seconds && (n = Number(this.evalExpr(e2.seconds, t2))), { text: s2, seconds: n };
+        }
+        resolveReplyFromFile(e2, t2, s2) {
+          let i2 = this.evalExpr(t2, s2), n = this._loadIndexedFile(e2, this._rootBasePath), r = n.get(Number(i2));
+          if (void 0 === r) throw Error(`runtime error: REPLY failed, entry ${i2} not found in "${e2}"`);
+          return r;
+        }
+        _loadIndexedFile(e2, t2) {
+          if (this._replyFileCache.has(e2)) return this._replyFileCache.get(e2);
+          let s2 = this.fileSystem.resolve(t2, e2);
+          if (!this.fileSystem.exists(s2)) throw Error(`runtime error: file not found: "${s2}"`);
+          let i2 = this.fileSystem.readFile(s2), n = this._parseIndexedEntries(i2, e2);
+          return this._replyFileCache.set(e2, n), n;
+        }
+        _parseIndexedEntries(e2, t2) {
+          let s2 = /* @__PURE__ */ new Map(), i2 = e2.length, n = 0;
+          for (; n < i2; ) {
+            let r = n, a = r;
+            for (; a < i2 && (" " === e2[a] || "	" === e2[a]); ) a++;
+            let l = /^\d+/.exec(e2.slice(a));
+            if (!l || "-" !== e2[a + l[0].length]) {
+              let o = e2.indexOf("\n", r);
+              n = -1 === o ? i2 : o + 1;
+              continue;
+            }
+            let h = Number(l[0]), u = a + l[0].length + 1;
+            if ("{" === e2[u]) {
+              let c = 1, f = u + 1, d = f;
+              for (; d < i2 && c > 0; ) "{" === e2[d] ? c++ : "}" === e2[d] && c--, d++;
+              if (0 !== c) throw Error(`runtime error: unclosed "{" for entry ${h} in "${t2}"`);
+              let p = e2.slice(f, d - 1).trim();
+              s2.set(h, p), n = d;
+              continue;
+            }
+            let m = e2.indexOf("\n", u), w = -1 === m ? i2 : m, g = e2.slice(u, w).trim();
+            s2.set(h, g), n = -1 === m ? i2 : m + 1;
+          }
+          return s2;
+        }
+        async execStatement(e2, t2) {
+          switch (e2.type) {
+            case "Reply": {
+              let s2 = e2.file ? this.resolveReplyFromFile(e2.file, e2.index, t2) : String(await this.evalReplyValue(e2.value, t2));
+              t2.vars.lastMsg = s2, this.onReply && await this.onReply({ target: e2.target, text: s2, client: t2.vars.client });
+              break;
+            }
+            case "Think": {
+              let i2 = this.resolveWaitingConfig(e2.waiting, t2), n = Date.now();
+              this.onThinking && await this.onThinking({ client: t2.vars.client, text: i2.text });
+              let r = this.fileSystem.resolve(this._rootBasePath, e2.file), a = this.knowledgeCache.get(r), l = a.analyze(t2.vars.message), o = Date.now() - n, h = 1e3 * i2.seconds - o;
+              if (h > 0 && await new Promise((e3) => setTimeout(e3, h)), "RESPONDER" === l.decision) {
+                let u = l.texto;
+                t2.vars.lastMsg = u, this.onReply && await this.onReply({ target: null, text: u, client: t2.vars.client });
+              } else e2.fallback && await this.execStatement(e2.fallback, t2);
+              break;
+            }
+            case "ForwardTo": {
+              let c = String(this.evalExpr(e2.target, t2));
+              this.onForward && await this.onForward({ target: c, client: t2.vars.client });
+              break;
+            }
+            case "ParseSignal":
+              t2.vars.SIGNAL = await this.signalParser(t2.rawSignal);
+              break;
+            case "SendTo":
+              this.onSend && await this.onSend({ target: e2.target, signal: t2.vars.SIGNAL });
+              break;
+            case "Insert":
+              this.execInsert(e2, t2);
+              break;
+            case "Update":
+              this.execUpdate(e2, t2);
+              break;
+            default:
+              throw Error(`runtime error: unsupported statement inside event: ${e2.type}`);
+          }
+        }
+        execInsert(e2, t2) {
+          let s2, i2;
+          "Context" !== e2.table || e2.columns && 0 !== e2.columns.length || e2.values ? (s2 = (e2.columns || []).map((e3) => e3.name), i2 = (e2.values || []).map((e3) => this.evalExpr(e3, t2))) : (s2 = ["client", "message", "created_at"], i2 = [t2.vars.client, t2.vars.message, (/* @__PURE__ */ new Date()).toISOString()]), t2.lastInsertId = this.db.insert(e2.table, s2, i2);
+        }
+        execUpdate(e2, t2) {
+          let s2 = this.evalExpr(e2.set.value, t2), i2 = null, n = null;
+          e2.where && (i2 = e2.where.left.name, n = this.evalExpr(e2.where.right, t2)), this.db.update(e2.table, e2.set.column, s2, i2, n);
+        }
+        async evalReplyValue(e2, t2) {
+          return "Call" === e2.type && "Response" === e2.callee ? this.execResponse(e2, t2) : this.evalExpr(e2, t2);
+        }
+        async execResponse(e2, t2) {
+          if (!this.onResponse) throw Error("runtime error: Response() failed, no AI connected (missing onResponse handler)");
+          let s2;
+          if (0 === e2.args.length) {
+            if (0 === this.responseConnections.size) throw Error("runtime error: Response() failed, no CONNECT RESPONSE found");
+            if (this.responseConnections.size > 1) throw Error(`runtime error: Response() is ambiguous with multiple CONNECT RESPONSE (${[...this.responseConnections].join(", ")}); use Response(alias)`);
+            s2 = [...this.responseConnections][0];
+          } else {
+            let i2 = e2.args[0];
+            if ("Identifier" !== i2.type) throw Error("runtime error: Response(alias) expects an alias name, not a string or expression");
+            if (s2 = i2.name, !this.responseConnections.has(s2)) throw Error(`runtime error: Response(${s2}) failed, no CONNECT RESPONSE ${s2} found`);
+          }
+          let n = this.envValues.get(s2), r = await this.onResponse({ alias: s2, token: n, message: t2.vars.message, client: t2.vars.client });
+          return r;
+        }
+        evalExpr(e2, t2) {
+          switch (e2.type) {
+            case "Literal":
+              return e2.value;
+            case "Identifier":
+              if ("env" === e2.name) return Object.fromEntries(this.envValues);
+              if (Object.prototype.hasOwnProperty.call(t2.vars, e2.name)) return t2.vars[e2.name];
+              if (this.envValues.has(e2.name)) return this.envValues.get(e2.name);
+              throw Error(`runtime error: unknown identifier: "${e2.name}"`);
+            case "Member": {
+              let s2 = this.evalExpr(e2.object, t2);
+              if (null == s2) return;
+              return s2[e2.property];
+            }
+            case "Call": {
+              if ("LAST_INSERT_ID" === e2.callee) return t2.lastInsertId;
+              let i2 = this.nativeFuncs.get(e2.callee);
+              if (!i2) throw Error(`runtime error: unknown function: "${e2.callee}"`);
+              let n = e2.args.map((e3) => this.evalExpr(e3, t2));
+              return i2(...n);
+            }
+            case "Binary": {
+              let r = this.evalExpr(e2.left, t2), a = this.evalExpr(e2.right, t2);
+              if ("+" === e2.op) {
+                if ("number" == typeof r && "number" == typeof a) return r + a;
+                return String(r) + String(a);
+              }
+              if ("=" === e2.op) return r === a;
+              throw Error(`runtime error: unsupported operator: "${e2.op}"`);
+            }
+            default:
+              throw Error(`runtime error: unsupported expression: ${e2.type}`);
+          }
+        }
+      };
+      module.exports = { BotQLInterpreter, MemoryDatabase: t };
+    }
+  });
+  return require_botql();
+})();