levix-bot 2.0.0

package/src/commands/calc.cjs

@@ -0,0 +1,387 @@
+// آلة حاسبة — !calc
+//
+// A self-contained expression evaluator. Deliberately NOT `eval()`: the input
+// comes straight from any group member, so we tokenize and parse it ourselves
+// and only ever touch the whitelisted functions below.
+//
+// Supports: + - * / % ^ (and ** ), parentheses, unary minus, implicit
+// multiplication (2(3+4), 3pi), postfix factorial (5!), percentages
+// (15%, «20% من 300»), Arabic-Indic digits, and the math functions listed in
+// FUNCTIONS.
+
+const { sendBotMessage } = require("../utils/sendBotMessage.cjs");
+
+// ---------------------------------------------------------------------------
+// whitelist
+// ---------------------------------------------------------------------------
+
+const CONSTANTS = {
+  pi: Math.PI,
+  π: Math.PI,
+  e: Math.E,
+  tau: Math.PI * 2,
+};
+
+const DEG = Math.PI / 180;
+
+const FUNCTIONS = {
+  sqrt: { arity: 1, fn: Math.sqrt },
+  cbrt: { arity: 1, fn: Math.cbrt },
+  abs: { arity: 1, fn: Math.abs },
+  round: { arity: 1, fn: Math.round },
+  floor: { arity: 1, fn: Math.floor },
+  ceil: { arity: 1, fn: Math.ceil },
+  sign: { arity: 1, fn: Math.sign },
+  ln: { arity: 1, fn: Math.log },
+  log: { arity: 1, fn: Math.log10 },
+  log2: { arity: 1, fn: Math.log2 },
+  exp: { arity: 1, fn: Math.exp },
+  sin: { arity: 1, fn: Math.sin },
+  cos: { arity: 1, fn: Math.cos },
+  tan: { arity: 1, fn: Math.tan },
+  asin: { arity: 1, fn: Math.asin },
+  acos: { arity: 1, fn: Math.acos },
+  atan: { arity: 1, fn: Math.atan },
+  // Degree variants — nobody types sin(rad(30)) in a chat.
+  sind: { arity: 1, fn: (x) => Math.sin(x * DEG) },
+  cosd: { arity: 1, fn: (x) => Math.cos(x * DEG) },
+  tand: { arity: 1, fn: (x) => Math.tan(x * DEG) },
+  deg: { arity: 1, fn: (x) => x / DEG },
+  rad: { arity: 1, fn: (x) => x * DEG },
+  fact: { arity: 1, fn: (x) => factorial(x) },
+  pow: { arity: 2, fn: Math.pow },
+  root: { arity: 2, fn: (x, n) => (n % 2 === 0 || x >= 0 ? Math.pow(x, 1 / n) : -Math.pow(-x, 1 / n)) },
+  hypot: { arity: -1, fn: (...a) => Math.hypot(...a) },
+  min: { arity: -1, fn: (...a) => Math.min(...a) },
+  max: { arity: -1, fn: (...a) => Math.max(...a) },
+  avg: { arity: -1, fn: (...a) => a.reduce((s, x) => s + x, 0) / a.length },
+  sum: { arity: -1, fn: (...a) => a.reduce((s, x) => s + x, 0) },
+};
+
+function factorial(n) {
+  if (!Number.isInteger(n)) throw new CalcError("المضروب (!) يشتغل على أرقام صحيحة بس");
+  if (n < 0) throw new CalcError("مفيش مضروب لرقم سالب");
+  if (n > 170) return Infinity; // beyond this a double is Infinity anyway
+  let result = 1;
+  for (let i = 2; i <= n; i++) result *= i;
+  return result;
+}
+
+class CalcError extends Error {}
+
+// ---------------------------------------------------------------------------
+// normalisation
+// ---------------------------------------------------------------------------
+
+const ARABIC_DIGITS = "٠١٢٣٤٥٦٧٨٩";
+const PERSIAN_DIGITS = "۰۱۲۳۴۵۶۷۸۹";
+
+function normalize(input) {
+  let text = String(input || "");
+
+  // Arabic-Indic / Persian digits -> ASCII
+  text = text.replace(/[٠-٩]/g, (d) => String(ARABIC_DIGITS.indexOf(d)));
+  text = text.replace(/[۰-۹]/g, (d) => String(PERSIAN_DIGITS.indexOf(d)));
+
+  // Arabic decimal separator + the symbols people paste from calculators
+  text = text
+    .replace(/٫/g, ".")
+    .replace(/\*\*/g, "^")
+    .replace(/[×✕✖]/g, "*")
+    .replace(/[÷➗]/g, "/")
+    .replace(/[−–—]/g, "-")
+    .replace(/(\d)\s*[xX]\s*(\d)/g, "$1*$2") // «3 x 4»
+    // thousands separators only — a comma between function arguments stays put
+    // (write `max(3, 900)` with a space so it isn't read as 3900)
+    .replace(/(?<=\d),(?=\d{3}(?!\d))/g, "");
+
+  // «20% من 300» / «20% of 300» -> (20/100)*300, so % stays modulo elsewhere.
+  text = text.replace(
+    /(\d+(?:\.\d+)?)\s*%\s*(?:of|من)\s*/gi,
+    (_, value) => `(${value}/100)*`
+  );
+
+  return text.trim();
+}
+
+// ---------------------------------------------------------------------------
+// tokenizer
+// ---------------------------------------------------------------------------
+
+function tokenize(text) {
+  const tokens = [];
+  let i = 0;
+
+  while (i < text.length) {
+    const char = text[i];
+
+    if (/\s/.test(char)) {
+      i++;
+      continue;
+    }
+
+    if (/[0-9.]/.test(char)) {
+      let raw = "";
+      while (i < text.length && /[0-9.]/.test(text[i])) raw += text[i++];
+      // scientific notation: 1e5, 2.5e-3
+      const signed = /[+-]/.test(text[i + 1] || "");
+      const exponentDigit = signed ? text[i + 2] : text[i + 1];
+      if (/[eE]/.test(text[i] || "") && /[0-9]/.test(exponentDigit || "")) {
+        raw += text[i++];
+        if (signed) raw += text[i++];
+        while (i < text.length && /[0-9]/.test(text[i])) raw += text[i++];
+      }
+      const value = Number(raw);
+      if (!Number.isFinite(value)) throw new CalcError(`رقم غير صالح: \`${raw}\``);
+      tokens.push({ type: "num", value });
+      continue;
+    }
+
+    if (/[a-zA-Zπ_]/.test(char)) {
+      let name = "";
+      while (i < text.length && /[a-zA-Z0-9π_]/.test(text[i])) name += text[i++];
+      tokens.push({ type: "ident", value: name.toLowerCase() });
+      continue;
+    }
+
+    if ("+-*/%^()!,".includes(char)) {
+      tokens.push({ type: char });
+      i++;
+      continue;
+    }
+
+    throw new CalcError(`رمز مش مفهوم: \`${char}\``);
+  }
+
+  return tokens;
+}
+
+// ---------------------------------------------------------------------------
+// parser (recursive descent)
+// ---------------------------------------------------------------------------
+
+function parse(tokens) {
+  let pos = 0;
+
+  const peek = (offset = 0) => tokens[pos + offset];
+  const eat = (type) => {
+    if (peek()?.type !== type) return null;
+    return tokens[pos++];
+  };
+  const expect = (type, message) => {
+    const token = eat(type);
+    if (!token) throw new CalcError(message);
+    return token;
+  };
+
+  // A token that can start a value — used for implicit multiplication.
+  const startsValue = (token) =>
+    !!token && (token.type === "num" || token.type === "ident" || token.type === "(");
+
+  function parseExpression() {
+    let left = parseTerm();
+    for (;;) {
+      if (eat("+")) left += parseTerm();
+      else if (eat("-")) left -= parseTerm();
+      else return left;
+    }
+  }
+
+  function parseTerm() {
+    let left = parseUnary();
+    for (;;) {
+      if (eat("*")) {
+        left *= parseUnary();
+      } else if (eat("/")) {
+        const right = parseUnary();
+        if (right === 0) throw new CalcError("القسمة على صفر ملهاش لازمة 😅");
+        left /= right;
+      } else if (peek()?.type === "%" && startsValue(peek(1))) {
+        // infix `%` is modulo; the postfix «15%» form is handled in parsePostfix
+        pos++;
+        const right = parseUnary();
+        if (right === 0) throw new CalcError("باقي القسمة على صفر مش معرّف");
+        left %= right;
+      } else if (startsValue(peek())) {
+        // implicit multiplication: 2(3+4), 3pi, 2sqrt(9)
+        left *= parseUnary();
+      } else {
+        return left;
+      }
+    }
+  }
+
+  function parseUnary() {
+    if (eat("-")) return -parseUnary();
+    if (eat("+")) return parseUnary();
+    return parsePower();
+  }
+
+  function parsePower() {
+    const base = parsePostfix();
+    if (eat("^")) return Math.pow(base, parseUnary()); // right-associative
+    return base;
+  }
+
+  function parsePostfix() {
+    let value = parsePrimary();
+    for (;;) {
+      if (eat("!")) {
+        value = factorial(value);
+      } else if (peek()?.type === "%" && !startsValue(peek(1))) {
+        pos++;
+        value /= 100;
+      } else {
+        return value;
+      }
+    }
+  }
+
+  function parsePrimary() {
+    const token = peek();
+    if (!token) throw new CalcError("المعادلة ناقصة");
+
+    if (eat("(")) {
+      const value = parseExpression();
+      expect(")", "قوس مفتوح ومقفلش");
+      return value;
+    }
+
+    if (token.type === "num") {
+      pos++;
+      return token.value;
+    }
+
+    if (token.type === "ident") {
+      pos++;
+      const name = token.value;
+
+      if (FUNCTIONS[name]) {
+        const spec = FUNCTIONS[name];
+        expect("(", `الدالة \`${name}\` محتاجة أقواس، زي \`${name}(9)\``);
+        const args = [];
+        if (peek()?.type !== ")") {
+          args.push(parseExpression());
+          while (eat(",")) args.push(parseExpression());
+        }
+        expect(")", `قوس \`${name}\` مقفلش`);
+        if (spec.arity !== -1 && args.length !== spec.arity) {
+          throw new CalcError(
+            `الدالة \`${name}\` بتاخد ${spec.arity} ${spec.arity === 1 ? "قيمة" : "قيم"}`
+          );
+        }
+        if (!args.length) throw new CalcError(`الدالة \`${name}\` من غير قيم`);
+        return spec.fn(...args);
+      }
+
+      if (name in CONSTANTS) return CONSTANTS[name];
+
+      throw new CalcError(`مش عارف يعني إيه \`${name}\``);
+    }
+
+    throw new CalcError(`مكان غلط للرمز \`${token.type}\``);
+  }
+
+  const result = parseExpression();
+  if (pos < tokens.length) throw new CalcError("في زيادة في آخر المعادلة");
+  return result;
+}
+
+function evaluate(expression) {
+  const normalized = normalize(expression);
+  if (!normalized) throw new CalcError("اكتب معادلة الأول");
+  if (normalized.length > 300) throw new CalcError("المعادلة طويلة أوي");
+
+  const value = parse(tokenize(normalized));
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new CalcError("النتيجة مش رقم صالح");
+  }
+  return { normalized, value };
+}
+
+// ---------------------------------------------------------------------------
+// formatting
+// ---------------------------------------------------------------------------
+
+function formatNumber(value) {
+  if (!Number.isFinite(value)) return value > 0 ? "∞" : "-∞";
+  if (Number.isInteger(value) && Math.abs(value) < 1e15) {
+    return value.toLocaleString("en-US");
+  }
+  const absolute = Math.abs(value);
+  if (absolute !== 0 && (absolute >= 1e15 || absolute < 1e-7)) {
+    return value.toExponential(6).replace(/e([+-])(\d)$/, "e$10$2");
+  }
+  // 0.1 + 0.2 should read 0.3, not 0.30000000000000004
+  const cleaned = Number(value.toPrecision(12));
+  const [whole, fraction] = String(cleaned).split(".");
+  const grouped = Number(whole).toLocaleString("en-US");
+  return fraction ? `${grouped}.${fraction}` : grouped;
+}
+
+const HELP_TEXT =
+  "🧮 *الآلة الحاسبة*\n\n" +
+  "*الاستخدام:* `!calc <معادلة>`\n" +
+  "أو رد على رسالة فيها معادلة واكتب `!calc`\n\n" +
+  "*العمليات:* `+` `-` `*` `/` `%` (باقي القسمة) `^` (أُس) `!` (مضروب)\n" +
+  "*النِّسب:* `15%` · `20% من 300`\n" +
+  "*الثوابت:* `pi` · `e` · `tau`\n" +
+  "*الدوال:* sqrt, cbrt, abs, round, floor, ceil, ln, log, log2, exp,\n" +
+  "sin, cos, tan, sind, cosd, tand, asin, acos, atan, deg, rad,\n" +
+  "pow, root, hypot, min, max, avg, sum, fact\n\n" +
+  "*أمثلة:*\n" +
+  "`!calc (12 + 8) * 3`\n" +
+  "`!calc 2^10`\n" +
+  "`!calc 25% من 480`\n" +
+  "`!calc sqrt(144) + 5!`\n" +
+  "`!calc max(3, 9, 4) * pi`";
+
+module.exports = {
+  name: "calc",
+  aliases: ["calculate", "حساب", "احسب", "="],
+  description: "آلة حاسبة: عمليات حسابية، نِسب، أُسس، ودوال رياضية.",
+  usage: "calc <معادلة>",
+  chat: "all",
+
+  async execute(sock, msg, args) {
+    const chatId = msg.key.remoteJid;
+
+    // Fall back to the quoted message so «رد على الرقم واكتب !calc» works.
+    const quoted = msg.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+    const quotedText =
+      quoted?.conversation || quoted?.extendedTextMessage?.text || "";
+
+    const expression = args.join(" ").trim() || quotedText.trim();
+
+    if (!expression) {
+      return sendBotMessage(sock, chatId, { text: HELP_TEXT }, { replyTo: msg });
+    }
+
+    try {
+      const { normalized, value } = evaluate(expression);
+      return sendBotMessage(
+        sock,
+        chatId,
+        {
+          text:
+            `🧮 \`${normalized}\`\n` +
+            `*=* ${formatNumber(value)}`,
+        },
+        { replyTo: msg }
+      );
+    } catch (error) {
+      const reason =
+        error instanceof CalcError ? error.message : "المعادلة مش مفهومة";
+      return sendBotMessage(
+        sock,
+        chatId,
+        { text: `❌ ${reason}\n\nاكتب \`!calc\` لوحده عشان تشوف الأمثلة.` },
+        { replyTo: msg }
+      );
+    }
+  },
+
+  // exported for reuse / quick sanity checks
+  _evaluate: evaluate,
+  _format: formatNumber,
+};

package/src/commands/debt.cjs

@@ -0,0 +1,175 @@
+// file: /commands/debt.cjs
+// Aliased on import: the command's own helpers below are named addDebt /
+// listDebts / deleteDebt too.
+const {
+  addDebt: storeAddDebt,
+  getDebt: storeGetDebt,
+  deleteDebt: storeDeleteDebt,
+  listDebts: storeListDebts,
+} = require("../utils/storage.cjs");
+const logger = require("../utils/logger.cjs");
+const normalizeJid = require("../utils/normalizeJid.esm.js").default;
+
+module.exports = {
+  name: "debt",
+  aliases: ["دين", "owes"],
+  description: "Private debt tracking system",
+  usage: "debt add <المبلغ> [الوصف]\ndebt del <id>\ndebt list",
+  chat: "private",
+
+  async execute(sock, msg, args) {
+    const remote = msg.key.remoteJid;
+    const senderId = normalizeJid(msg.key.participant || remote);
+
+    // private chat: the person you're talking to
+    const targetId = normalizeJid(msg.key.remoteJidAlt);
+    const chatKey = "private-" + targetId;
+
+    const sub = (args[0] || "").toLowerCase();
+
+    switch (sub) {
+      case "add":
+      case "اضافة":
+        await addDebt(sock, msg, args.slice(1), senderId, targetId, chatKey);
+        break;
+
+      case "del":
+      case "حذف":
+        await deleteDebt(sock, msg, args.slice(1), senderId, targetId, chatKey);
+        break;
+
+      case "list":
+      case "قائمة":
+        await listDebts(sock, msg, senderId, targetId, chatKey);
+        break;
+
+      default:
+        await sock.sendMessage(remote, {
+          text:
+            `📊 *نظام الديون (خاص فقط)*\n\n` +
+            `الأوامر:\n\n` +
+            `• \`!debt add <amount> [description]\` — إضافة دين\n` +
+            `• \`!debt list\` — عرض الديون\n` +
+            `• \`!debt del <id>\` — حذف دين\n\n` +
+            `مثال:\n\`!debt add 50 غداء\``,
+        });
+    }
+  },
+};
+
+async function addDebt(sock, msg, args, creditorId, debtorId, chatKey) {
+  const remote = msg.key.remoteJid;
+
+  if (args.length < 1) {
+    return sock.sendMessage(remote, {
+      text: "❌ الاستخدام: `!debt add <amount> [description]`",
+    });
+  }
+
+  const amount = parseFloat(args[0]);
+  const description = args.slice(1).join(" ") || "بدون وصف";
+
+  if (isNaN(amount) || amount <= 0) {
+    return sock.sendMessage(remote, {
+      text: "❌ المبلغ يجب أن يكون رقم موجب",
+    });
+  }
+
+  try {
+    const debt = storeAddDebt({
+      groupId: chatKey,
+      debtorId,
+      creditorId,
+      amount,
+      description,
+    });
+
+    await sock.sendMessage(remote, {
+      text:
+        `✅ *تم إضافة الدين*\n\n` +
+        `المدين: ${debtorId.split("@")[0]}\n` +
+        `الدائن: ${creditorId.split("@")[0]}\n` +
+        `المبلغ: ${amount}\n` +
+        `الوصف: ${description}\n` +
+        `رقم السجل: #${debt.id}`,
+    });
+  } catch (err) {
+    logger.error(err, "[Debt] Add error:");
+    await sock.sendMessage(remote, {
+      text: "❌ حدث خطأ أثناء تسجيل الدين",
+    });
+  }
+}
+
+async function listDebts(sock, msg, creditorId, debtorId, chatKey) {
+  const remote = msg.key.remoteJid;
+
+  try {
+    const debts = storeListDebts(chatKey, { settled: false });
+
+    if (debts.length === 0) {
+      return sock.sendMessage(remote, { text: "لا توجد ديون حالياً ✅" });
+    }
+
+    let text = "📋 *قائمة الديون:*\n\n";
+
+    debts.forEach((d) => {
+      const date = new Date(d.created_at).toLocaleDateString("ar-EG");
+      text += `*#${d.id}*\n`;
+      text += `المدين: ${d.debtor_id.split("@")[0]}\n`;
+      text += `الدائن: ${d.creditor_id.split("@")[0]}\n`;
+      text += `المبلغ: ${d.amount}\n`;
+      text += `الوصف: ${d.description}\n`;
+      text += `التاريخ: ${date}\n\n`;
+    });
+
+    await sock.sendMessage(remote, { text });
+  } catch (err) {
+    logger.error(err, "[Debt] List error:");
+    await sock.sendMessage(remote, {
+      text: "❌ حدث خطأ أثناء عرض الديون",
+    });
+  }
+}
+
+async function deleteDebt(sock, msg, args, creditorId, debtorId, chatKey) {
+  const remote = msg.key.remoteJid;
+
+  if (args.length < 1) {
+    return sock.sendMessage(remote, {
+      text: "❌ الاستخدام: `!debt del <id>`",
+    });
+  }
+
+  const id = parseInt(args[0]);
+  if (isNaN(id)) {
+    return sock.sendMessage(remote, {
+      text: "❌ رقم السجل غير صحيح",
+    });
+  }
+
+  try {
+    const debt = storeGetDebt(id);
+
+    if (!debt) {
+      return sock.sendMessage(remote, { text: "❌ لم يتم العثور على الدين" });
+    }
+
+    if (debt.group_id !== chatKey) {
+      return sock.sendMessage(remote, {
+        text: "❌ هذا الدين لا يخص هذه المحادثة",
+      });
+    }
+
+    storeDeleteDebt(id);
+
+    await sock.sendMessage(remote, {
+      text: `🗑️ تم حذف الدين رقم #${id} بنجاح`,
+    });
+  } catch (err) {
+    logger.error(err, "[Debt] Del error:");
+    await sock.sendMessage(remote, {
+      text: "❌ حدث خطأ أثناء حذف الدين",
+    });
+  }
+}

package/src/commands/deleteschedule.cjs

@@ -0,0 +1,36 @@
+// file: /commands/deleteschedule.js
+const { deleteScheduledJob, getScheduledJobs } = require("../../scheduler.cjs");
+
+module.exports = {
+  name: "deleteschedule",
+  description: "Deletes a scheduled job by its ID.",
+  usage: "deleteschedule <id>",
+  chat: "all",
+  userAdminRequired: true,
+
+  async execute(sock, msg, args) {
+    const jobIdToDelete = args[0];
+
+    if (!jobIdToDelete) {
+      return await sock.sendMessage(msg.key.remoteJid, {
+        text: "يرجى تحديد ID المهمة التي تريد حذفها. يمكنك الحصول على الـ ID باستخدام أمر `!listschedules`.",
+      });
+    }
+
+    const jobs = getScheduledJobs();
+    const jobExists = jobs.some((job) => job.id === jobIdToDelete);
+
+    if (!jobExists) {
+      return await sock.sendMessage(msg.key.remoteJid, {
+        text: `⚠️ لم يتم العثور على مهمة بهذا الـ ID: \`${jobIdToDelete}\``,
+      });
+    }
+
+    // This function stops the running task and removes it from the JSON file
+    deleteScheduledJob(jobIdToDelete);
+
+    await sock.sendMessage(msg.key.remoteJid, {
+      text: `✅ تم حذف المهمة المجدولة بالـ ID: \`${jobIdToDelete}\` بنجاح.`,
+    });
+  },
+};