@tryty/easydc-js 0.0.0-stage → 1.1.0

package/src/functions/manage.js

@@ -0,0 +1,171 @@
+'use strict';
+const { BotError } = require('../errors');
+const { f, has, truthy, cleanId, num, limit, fetchChannel, channelOrCurrent, getRole } = require('./helpers');
+const { parseColor } = require('./embed');
+
+const CHANNEL_TYPES = { text: 0, voice: 2, category: 4, announcement: 5, stage: 13, forum: 15 };
+const TYPE_NAMES = {
+  0: 'text', 1: 'dm', 2: 'voice', 3: 'groupdm', 4: 'category', 5: 'announcement',
+  10: 'announcement_thread', 11: 'public_thread', 12: 'private_thread', 13: 'stage', 15: 'forum', 16: 'media',
+};
+const reason = (r) => (has(r) ? r : undefined);
+
+// PERHATIAN: semua fungsi di file ini memakai izin BOT dan mengubah server.
+// Selalu lindungi command dengan $onlyPerms[...] / $onlyAdmin / $onlyOwner.
+module.exports = [
+  // ---- Ban --------------------------------------------------------------------
+  f('unban', { b: 'required', min: 1, max: 2, s: '[userID;alasan?]', d: 'Cabut ban user' },
+    async (ctx, [id, r]) => { await ctx.requireGuild().members.unban(cleanId(id), reason(r)); return ''; }),
+  f('isBanned', { b: 'required', min: 1, max: 1, s: '[userID]', d: 'true/false: user sedang di-ban di server ini' },
+    async (ctx, [id]) => {
+      try {
+        await ctx.requireGuild().bans.fetch(cleanId(id));
+        return 'true';
+      } catch (e) {
+        if (e.code === 10026 || /unknown ban/i.test(e.message)) return 'false';
+        throw e;
+      }
+    }),
+  f('banCount', { b: 'none', d: 'Jumlah user ter-ban (dibaca maks 1000 teratas)' },
+    async (ctx) => (await ctx.requireGuild().bans.fetch()).size),
+
+  // ---- Channel ----------------------------------------------------------------
+  f('createChannel', { b: 'required', min: 1, max: 4, s: '[nama;tipe?;parentID?;topik?]', d: 'Buat channel. Tipe: text voice category announcement stage forum. Mengembalikan ID' },
+    async (ctx, [name, type, parent, topic]) => {
+      const g = ctx.requireGuild();
+      const key = has(type) ? type.trim().toLowerCase() : 'text';
+      if (!Object.hasOwn(CHANNEL_TYPES, key)) throw new BotError(`Tipe channel "${type}" tidak valid (${Object.keys(CHANNEL_TYPES).join(', ')})`);
+      const n = name.trim();
+      if (!n) throw new BotError('Nama channel tidak boleh kosong');
+      const opts = { name: limit('nama', n, 100), type: CHANNEL_TYPES[key] };
+      if (has(parent)) opts.parent = cleanId(parent);
+      if (has(topic) && [0, 5, 15].includes(opts.type)) opts.topic = limit('topik', topic, 1024);
+      return (await g.channels.create(opts)).id;
+    }),
+  f('deleteChannel', { b: 'required', min: 1, max: 2, s: '[channelID;alasan?]', d: 'Hapus channel/thread (menghapus channel saat ini membuat jawaban gagal terkirim)' },
+    async (ctx, [id, r]) => { await (await fetchChannel(ctx, id)).delete(reason(r)); return ''; }),
+  f('setChannelName', { b: 'required', min: 2, max: 3, s: '[channelID;nama;alasan?]', d: 'Ubah nama channel' },
+    async (ctx, [id, name, r]) => {
+      if (!name.trim()) throw new BotError('Nama channel tidak boleh kosong');
+      await (await fetchChannel(ctx, id)).setName(limit('nama', name.trim(), 100), reason(r));
+      return '';
+    }),
+  f('setChannelTopic', { b: 'required', min: 2, max: 3, s: '[channelID;topik;alasan?]', d: 'Ubah topik channel' },
+    async (ctx, [id, topic, r]) => {
+      const ch = await fetchChannel(ctx, id);
+      if (typeof ch.setTopic !== 'function') throw new BotError('Channel itu tidak punya topik');
+      await ch.setTopic(limit('topik', topic, 1024), reason(r));
+      return '';
+    }),
+  f('lockChannel', { max: 2, s: '[channelID?;alasan?]', d: 'Kunci channel: @everyone tidak bisa mengirim pesan' },
+    async (ctx, [id, r]) => {
+      const ch = await channelOrCurrent(ctx, id);
+      if (!ch.permissionOverwrites) throw new BotError('Channel ini tidak bisa dikunci');
+      await ch.permissionOverwrites.edit(ch.guild.roles.everyone, { SendMessages: false }, { reason: reason(r) });
+      return '';
+    }),
+  f('unlockChannel', { max: 2, s: '[channelID?;alasan?]', d: 'Buka kunci channel (kembali ke pengaturan semula)' },
+    async (ctx, [id, r]) => {
+      const ch = await channelOrCurrent(ctx, id);
+      if (!ch.permissionOverwrites) throw new BotError('Channel ini tidak bisa dibuka kuncinya');
+      await ch.permissionOverwrites.edit(ch.guild.roles.everyone, { SendMessages: null }, { reason: reason(r) });
+      return '';
+    }),
+  f('createInvite', { max: 3, s: '[channelID?;umurDetik?;maxPakai?]', d: 'Buat link undangan. Umur 0-604800 (0 = selamanya), maxPakai 0-100. Mengembalikan URL' },
+    async (ctx, [id, age, uses]) => {
+      const ch = await channelOrCurrent(ctx, id);
+      if (typeof ch.createInvite !== 'function') throw new BotError('Channel itu tidak bisa dibuat undangan');
+      const opts = {};
+      if (has(age)) opts.maxAge = num(age, 'umur', { min: 0, max: 604800, int: true });
+      if (has(uses)) opts.maxUses = num(uses, 'maxPakai', { min: 0, max: 100, int: true });
+      return (await ch.createInvite(opts)).url;
+    }),
+  f('channelType', { max: 1, s: '[channelID?]', d: 'Tipe channel: text voice category announcement stage forum dst.' },
+    async (ctx, [id]) => {
+      const ch = await channelOrCurrent(ctx, id);
+      return TYPE_NAMES[ch.type] ?? String(ch.type);
+    }),
+
+  // ---- Role -------------------------------------------------------------------
+  f('createRole', { b: 'required', min: 1, max: 5, s: '[nama;warna?;hoist?;mentionable?;alasan?]', d: 'Buat role. Mengembalikan ID' },
+    async (ctx, [name, color, hoist, mentionable, r]) => {
+      if (!name.trim()) throw new BotError('Nama role tidak boleh kosong');
+      const opts = { name: limit('nama', name.trim(), 100), hoist: truthy(hoist), mentionable: truthy(mentionable), reason: reason(r) };
+      if (has(color)) opts.color = parseColor(color);
+      return (await ctx.requireGuild().roles.create(opts)).id;
+    }),
+  f('deleteRole', { b: 'required', min: 1, max: 2, s: '[roleID;alasan?]', d: 'Hapus role' },
+    async (ctx, [id, r]) => { await getRole(ctx, id).delete(reason(r)); return ''; }),
+  f('setRoleName', { b: 'required', min: 2, max: 3, s: '[roleID;nama;alasan?]', d: 'Ubah nama role' },
+    async (ctx, [id, name, r]) => {
+      if (!name.trim()) throw new BotError('Nama role tidak boleh kosong');
+      await getRole(ctx, id).setName(limit('nama', name.trim(), 100), reason(r));
+      return '';
+    }),
+  f('setRoleColor', { b: 'required', min: 2, max: 3, s: '[roleID;warna;alasan?]', d: 'Ubah warna role (#hex / nama / random)' },
+    async (ctx, [id, color, r]) => { await getRole(ctx, id).setColor(parseColor(color), reason(r)); return ''; }),
+  f('memberRoles', { max: 1, s: '[userID?]', d: 'Daftar ID role member, dipisah koma' },
+    async (ctx, [id]) => {
+      const m = await ctx.fetchMember(id);
+      return [...m.roles.cache.keys()].filter((rid) => rid !== ctx.guild.id).join(',');
+    }),
+
+  // ---- Emoji & event ------------------------------------------------------------
+  f('createEmoji', { b: 'required', min: 2, max: 2, s: '[nama;url]', d: 'Tambah emoji dari URL gambar. Mengembalikan emoji siap pakai' },
+    async (ctx, [name, u]) => {
+      if (!/^\w{2,32}$/.test(name)) throw new BotError('Nama emoji harus 2-32 karakter (huruf, angka, _)');
+      if (!/^https?:\/\/\S+$/i.test(u.trim())) throw new BotError('URL gambar emoji tidak valid');
+      return String(await ctx.requireGuild().emojis.create({ attachment: u.trim(), name }));
+    }),
+  f('deleteEmoji', { b: 'required', min: 1, max: 1, s: '[emojiID]', d: 'Hapus emoji server' },
+    async (ctx, [id]) => {
+      const e = ctx.requireGuild().emojis.cache.get(cleanId(id));
+      if (!e) throw new BotError(`Emoji "${id}" tidak ditemukan di server ini`);
+      await e.delete();
+      return '';
+    }),
+  f('createEvent', { b: 'required', min: 4, max: 5, s: '[nama;mulaiMs;selesaiMs;lokasi;deskripsi?]', d: 'Buat scheduled event (di luar Discord). Waktu dalam ms (lihat $timestamp). Mengembalikan ID' },
+    async (ctx, [name, start, end, location, description]) => {
+      const s = num(start, 'mulai', { int: true });
+      const e = num(end, 'selesai', { int: true });
+      if (s <= Date.now()) throw new BotError('Waktu mulai harus di masa depan');
+      if (e <= s) throw new BotError('Waktu selesai harus setelah waktu mulai');
+      if (!name.trim() || !location.trim()) throw new BotError('Nama dan lokasi event tidak boleh kosong');
+      const opts = {
+        name: limit('nama', name.trim(), 100),
+        scheduledStartTime: new Date(s),
+        scheduledEndTime: new Date(e),
+        privacyLevel: 2,
+        entityType: 3,
+        entityMetadata: { location: limit('lokasi', location.trim(), 100) },
+      };
+      if (has(description)) opts.description = limit('deskripsi', description, 1000);
+      return (await ctx.requireGuild().scheduledEvents.create(opts)).id;
+    }),
+
+  // ---- Voice ------------------------------------------------------------------
+  f('moveMember', { b: 'required', min: 2, max: 2, s: '[userID;voiceChannelID]', d: 'Pindahkan member ke voice channel lain' },
+    async (ctx, [id, ch]) => {
+      const m = await ctx.fetchMember(id);
+      if (!m.voice?.channel) throw new BotError('Member itu sedang tidak berada di voice channel');
+      await m.voice.setChannel(cleanId(ch));
+      return '';
+    }),
+  f('disconnectMember', { b: 'required', min: 1, max: 1, s: '[userID]', d: 'Keluarkan member dari voice channel' },
+    async (ctx, [id]) => {
+      const m = await ctx.fetchMember(id);
+      if (!m.voice?.channel) throw new BotError('Member itu sedang tidak berada di voice channel');
+      await m.voice.setChannel(null);
+      return '';
+    }),
+
+  // ---- Bot ----------------------------------------------------------------------
+  f('leaveServer', { max: 1, s: '[serverID?]', d: 'Bot keluar dari server. Hanya untuk owner bot' },
+    async (ctx, [id]) => {
+      if (!ctx.bot.options.owners.includes(ctx.user?.id)) throw new BotError('$leaveServer hanya untuk owner bot');
+      const g = has(id) ? ctx.client.guilds.cache.get(cleanId(id)) : ctx.requireGuild();
+      if (!g) throw new BotError(`Server "${id}" tidak ditemukan`);
+      await g.leave();
+      return '';
+    }),
+];

package/src/functions/messages.js

@@ -0,0 +1,128 @@
+'use strict';
+const { BotError } = require('../errors');
+const {
+  f, has, truthy, cleanId, num, url, limit, fetchChannel, channelOrCurrent, fetchMessage,
+} = require('./helpers');
+
+const WEBHOOK_RE = /^https:\/\/(?:ptb\.|canary\.)?(?:discord|discordapp)\.com\/api(?:\/v\d+)?\/webhooks\/\d+\/[\w-]+$/;
+const ARCHIVE = [60, 1440, 4320, 10080];
+const MAX_FILE_BYTES = 1_000_000;
+
+async function getThread(ctx, id) {
+  const th = await channelOrCurrent(ctx, id);
+  if (typeof th.isThread !== 'function' || !th.isThread()) throw new BotError('Channel itu bukan thread');
+  return th;
+}
+
+// PERHATIAN: fungsi di file ini memakai izin BOT. Lindungi command dengan $onlyPerms / $onlyAdmin / $onlyOwner.
+module.exports = [
+  f('editMessage', { b: 'required', min: 2, max: 3, s: '[messageID;teks;channelID?]', d: 'Edit pesan milik bot sendiri' },
+    async (ctx, [mid, text, cid]) => {
+      if (!text.trim()) throw new BotError('Teks baru tidak boleh kosong');
+      const m = await fetchMessage(ctx, mid, cid);
+      if (m.author?.id !== ctx.client.user.id) throw new BotError('Bot hanya bisa mengedit pesannya sendiri');
+      await m.edit({ content: limit('teks', text, 2000) });
+      return '';
+    }),
+  f('deleteMessage', { b: 'required', min: 1, max: 2, s: '[messageID;channelID?]', d: 'Hapus satu pesan' },
+    async (ctx, [mid, cid]) => { await (await fetchMessage(ctx, mid, cid)).delete(); return ''; }),
+  f('pinMessage', { b: 'required', min: 1, max: 2, s: '[messageID;channelID?]', d: 'Sematkan (pin) pesan' },
+    async (ctx, [mid, cid]) => { await (await fetchMessage(ctx, mid, cid)).pin(); return ''; }),
+  f('unpinMessage', { b: 'required', min: 1, max: 2, s: '[messageID;channelID?]', d: 'Lepas pin pesan' },
+    async (ctx, [mid, cid]) => { await (await fetchMessage(ctx, mid, cid)).unpin(); return ''; }),
+  f('addReaction', { b: 'required', min: 2, max: 3, s: '[messageID;emoji;channelID?]', d: 'Beri reaksi pada pesan tertentu' },
+    async (ctx, [mid, emoji, cid]) => {
+      if (!emoji.trim()) throw new BotError('Emoji tidak boleh kosong');
+      await (await fetchMessage(ctx, mid, cid)).react(emoji.trim());
+      return '';
+    }),
+  f('messageContentOf', { b: 'required', min: 1, max: 2, s: '[messageID;channelID?]', d: 'Isi teks pesan tertentu' },
+    async (ctx, [mid, cid]) => (await fetchMessage(ctx, mid, cid)).content ?? ''),
+  f('messageAuthorOf', { b: 'required', min: 1, max: 2, s: '[messageID;channelID?]', d: 'ID pengirim pesan tertentu' },
+    async (ctx, [mid, cid]) => (await fetchMessage(ctx, mid, cid)).author?.id ?? ''),
+
+  f('addAttachment', { b: 'required', min: 1, max: 2, s: '[url;nama?]', d: 'Lampirkan file dari URL http(s) ke jawaban (maks 10)' },
+    (ctx, [u, name]) => {
+      if (ctx.files.length >= 10) throw new BotError('Maksimal 10 lampiran per pesan');
+      const file = { attachment: url(u, 'URL lampiran') };
+      if (has(name)) file.name = limit('nama file', name.trim(), 100);
+      ctx.files.push(file);
+      return '';
+    }),
+  f('addTextFile', { b: 'required', min: 2, max: 2, s: '[namaFile;isi]', d: 'Lampirkan file teks buatan sendiri (maks 1 MB)' },
+    (ctx, [name, content]) => {
+      if (ctx.files.length >= 10) throw new BotError('Maksimal 10 lampiran per pesan');
+      if (!/^[\w .-]{1,100}$/.test(name)) throw new BotError(`Nama file "${name}" tidak valid (huruf, angka, spasi, . - _)`);
+      if (Buffer.byteLength(content) > MAX_FILE_BYTES) throw new BotError('Isi file terlalu besar (maks 1 MB)');
+      ctx.files.push({ attachment: Buffer.from(content, 'utf8'), name });
+      return '';
+    }),
+  f('poll', { b: 'required', min: 5, max: 13, s: '[pertanyaan;jam;multi;opsi1;opsi2;...]', d: 'Buat polling (jam 1-768, multi = true/false, 2-10 opsi)' },
+    (ctx, [question, hours, multi, ...answers]) => {
+      if (ctx.poll) throw new BotError('Hanya satu polling per pesan');
+      if (!question.trim()) throw new BotError('Pertanyaan polling tidak boleh kosong');
+      if (answers.some((a) => !a.trim())) throw new BotError('Opsi polling tidak boleh kosong');
+      ctx.poll = {
+        question: { text: limit('pertanyaan', question.trim(), 300) },
+        answers: answers.map((a) => ({ text: limit('opsi', a.trim(), 55) })),
+        duration: num(hours, 'jam', { min: 1, max: 768, int: true }),
+        allowMultiselect: truthy(multi),
+      };
+      return '';
+    }),
+  f('sendWebhook', { b: 'required', min: 2, max: 4, s: '[webhookURL;teks;username?;avatarURL?]', d: 'Kirim pesan lewat URL webhook Discord' },
+    async (ctx, [hook, text, username, avatar]) => {
+      const u = hook.trim();
+      if (!WEBHOOK_RE.test(u)) throw new BotError('URL webhook tidak valid (harus https://discord.com/api/webhooks/ID/TOKEN)');
+      if (!text.trim()) throw new BotError('Teks webhook tidak boleh kosong');
+      const body = { content: limit('teks', text, 2000), allowed_mentions: { parse: [] } };
+      if (has(username)) body.username = limit('username', username, 80);
+      if (has(avatar)) body.avatar_url = url(avatar, 'avatar');
+      const res = await fetch(u, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(10000),
+      });
+      if (!res.ok) throw new BotError(`Webhook gagal (HTTP ${res.status})`);
+      return '';
+    }),
+
+  f('createThread', { b: 'required', min: 1, max: 3, s: '[nama;messageID?;arsipOtomatisMenit?]', d: 'Buat thread (dari pesan bila messageID diisi). Arsip: 60/1440/4320/10080. Mengembalikan ID thread' },
+    async (ctx, [name, mid, archive]) => {
+      if (!name.trim()) throw new BotError('Nama thread tidak boleh kosong');
+      const opts = { name: limit('nama', name.trim(), 100) };
+      if (has(archive)) {
+        const a = num(archive, 'arsip', { int: true });
+        if (!ARCHIVE.includes(a)) throw new BotError(`Arsip otomatis harus salah satu dari ${ARCHIVE.join(', ')} menit`);
+        opts.autoArchiveDuration = a;
+      }
+      let thread;
+      if (has(mid)) {
+        thread = await (await fetchMessage(ctx, mid)).startThread(opts);
+      } else {
+        if (!ctx.channel?.threads || typeof ctx.channel.threads.create !== 'function') throw new BotError('Channel ini tidak mendukung thread');
+        thread = await ctx.channel.threads.create(opts);
+      }
+      return thread.id;
+    }),
+  f('archiveThread', { max: 2, s: '[threadID?;kunci?]', d: 'Arsipkan thread (kunci = true untuk sekalian dikunci)' },
+    async (ctx, [id, lock]) => {
+      const th = await getThread(ctx, id);
+      if (truthy(lock)) await th.setLocked(true);
+      await th.setArchived(true);
+      return '';
+    }),
+  f('addThreadMember', { b: 'required', min: 1, max: 2, s: '[userID;threadID?]', d: 'Tambahkan user ke thread' },
+    async (ctx, [uid, tid]) => { await (await getThread(ctx, tid)).members.add(cleanId(uid)); return ''; }),
+  f('removeThreadMember', { b: 'required', min: 1, max: 2, s: '[userID;threadID?]', d: 'Keluarkan user dari thread' },
+    async (ctx, [uid, tid]) => { await (await getThread(ctx, tid)).members.remove(cleanId(uid)); return ''; }),
+  f('createForumPost', { b: 'required', min: 3, max: 3, s: '[forumID;judul;isi]', d: 'Buat postingan di channel forum. Mengembalikan ID thread' },
+    async (ctx, [forumId, title, text]) => {
+      const ch = await fetchChannel(ctx, forumId);
+      if (!ch.threads || typeof ch.threads.create !== 'function') throw new BotError('Channel itu bukan channel forum');
+      if (!title.trim() || !text.trim()) throw new BotError('Judul dan isi postingan tidak boleh kosong');
+      const post = await ch.threads.create({ name: limit('judul', title.trim(), 100), message: { content: limit('isi', text, 2000) } });
+      return post.id;
+    }),
+];

package/src/functions/text.js

@@ -0,0 +1,118 @@
+'use strict';
+const { BotError } = require('../errors');
+const { safeMath, formatNumber, numberSeparator } = require('../util');
+const { f, has, truthy, cleanId, list, num } = require('./helpers');
+
+const nums = (args, label = 'angka') => args.map((a, i) => num(a, `${label} ke-${i + 1}`));
+
+module.exports = [
+  // ---- Matematika -----------------------------------------------------------
+  f('math', { b: 'required', min: 1, max: 1, s: '[ekspresi]', d: 'Hitung aman. Dukung + - * / % ^ ( ) sqrt abs round floor ceil min max pow pi e' },
+    (ctx, [expr]) => formatNumber(safeMath(expr))),
+  f('sum', { b: 'required', min: 1, s: '[a;b;...]', d: 'Jumlah semua angka' },
+    (ctx, args) => formatNumber(nums(args).reduce((a, b) => a + b, 0))),
+  f('sub', { b: 'required', min: 2, max: 2, s: '[a;b]', d: 'a - b' },
+    (ctx, args) => { const [a, b] = nums(args); return formatNumber(a - b); }),
+  f('multiply', { b: 'required', min: 1, s: '[a;b;...]', d: 'Kali semua angka' },
+    (ctx, args) => formatNumber(nums(args).reduce((a, b) => a * b, 1))),
+  f('divide', { b: 'required', min: 2, max: 2, s: '[a;b]', d: 'a / b' },
+    (ctx, args) => {
+      const [a, b] = nums(args);
+      if (b === 0) throw new BotError('Pembagian dengan nol');
+      return formatNumber(a / b);
+    }),
+  f('modulo', { b: 'required', min: 2, max: 2, s: '[a;b]', d: 'Sisa bagi a % b' },
+    (ctx, args) => {
+      const [a, b] = nums(args);
+      if (b === 0) throw new BotError('Pembagian dengan nol');
+      return formatNumber(a % b);
+    }),
+  f('round', { b: 'required', min: 1, max: 2, s: '[angka;desimal?]', d: 'Bulatkan angka' },
+    (ctx, [n, dec]) => {
+      const d = has(dec) ? num(dec, 'desimal', { min: 0, max: 10, int: true }) : 0;
+      const p = 10 ** d;
+      return formatNumber(Math.round(num(n, 'angka') * p) / p);
+    }),
+  f('max', { b: 'required', min: 1, s: '[a;b;...]', d: 'Angka terbesar' },
+    (ctx, args) => formatNumber(Math.max(...nums(args)))),
+  f('min', { b: 'required', min: 1, s: '[a;b;...]', d: 'Angka terkecil' },
+    (ctx, args) => formatNumber(Math.min(...nums(args)))),
+  f('random', { b: 'required', min: 2, max: 2, s: '[min;max]', d: 'Bilangan bulat acak (inklusif)' },
+    (ctx, [a, b]) => {
+      const lo = num(a, 'min', { int: true });
+      const hi = num(b, 'max', { int: true });
+      if (lo > hi) throw new BotError('min tidak boleh lebih besar dari max');
+      return Math.floor(Math.random() * (hi - lo + 1)) + lo;
+    }),
+  f('randomText', { b: 'required', min: 1, s: '[a;b;...]', d: 'Pilih salah satu teks secara acak' },
+    (ctx, args) => args[Math.floor(Math.random() * args.length)]),
+  f('numberSeparator', { b: 'required', min: 1, max: 2, s: '[angka;pemisah?]', d: '1234567 -> 1,234,567' },
+    (ctx, [n, sep]) => numberSeparator(n, has(sep) ? sep : ',')),
+
+  // ---- Teks -----------------------------------------------------------------
+  f('toUpperCase', { b: 'required', min: 1, max: 1, s: '[teks]', d: 'HURUF BESAR' }, (ctx, [t]) => t.toUpperCase()),
+  f('toLowerCase', { b: 'required', min: 1, max: 1, s: '[teks]', d: 'huruf kecil' }, (ctx, [t]) => t.toLowerCase()),
+  f('capitalize', { b: 'required', min: 1, max: 1, s: '[teks]', d: 'Huruf pertama jadi besar' },
+    (ctx, [t]) => t.charAt(0).toUpperCase() + t.slice(1)),
+  f('titleCase', { b: 'required', min: 1, max: 1, s: '[teks]', d: 'Huruf Pertama Tiap Kata Besar' },
+    (ctx, [t]) => t.toLowerCase().replace(/(^|\s)(\S)/g, (m, sp, c) => sp + c.toUpperCase())),
+  f('trimSpace', { b: 'required', min: 1, max: 1, s: '[teks]', d: 'Hapus spasi di awal/akhir' }, (ctx, [t]) => t.trim()),
+  f('length', { b: 'required', min: 1, max: 1, s: '[teks]', d: 'Jumlah karakter' }, (ctx, [t]) => [...t].length),
+  f('reverse', { b: 'required', min: 1, max: 1, s: '[teks]', d: 'Balik urutan teks' }, (ctx, [t]) => [...t].reverse().join('')),
+  f('repeat', { b: 'required', min: 2, max: 2, s: '[teks;jumlah]', d: 'Ulang teks (maks 100x)' },
+    (ctx, [t, n]) => t.repeat(num(n, 'jumlah', { min: 0, max: 100, int: true }))),
+  f('substring', { b: 'required', min: 2, max: 3, s: '[teks;awal;akhir?]', d: 'Potong teks (indeks mulai 0)' },
+    (ctx, [t, a, b]) => [...t].slice(num(a, 'awal', { int: true, min: 0 }), has(b) ? num(b, 'akhir', { int: true, min: 0 }) : undefined).join('')),
+  f('replaceText', { b: 'required', min: 3, max: 4, s: '[teks;cari;ganti;batas?]', d: 'Ganti teks (semua, atau N pertama)' },
+    (ctx, [t, from, to, lim]) => {
+      if (from === '') throw new BotError('Teks yang dicari tidak boleh kosong');
+      if (!has(lim)) return t.split(from).join(to);
+      let left = num(lim, 'batas', { min: 1, int: true });
+      let out = '';
+      let rest = t;
+      while (left > 0) {
+        const idx = rest.indexOf(from);
+        if (idx === -1) break;
+        out += rest.slice(0, idx) + to;
+        rest = rest.slice(idx + from.length);
+        left--;
+      }
+      return out + rest;
+    }),
+  f('split', { b: 'required', min: 3, max: 3, s: '[teks;pemisah;nomor]', d: 'Ambil bagian ke-N setelah memecah teks' },
+    (ctx, [t, sep, n]) => {
+      if (sep === '') throw new BotError('Pemisah tidak boleh kosong');
+      return t.split(sep)[num(n, 'nomor', { min: 1, int: true }) - 1] ?? '';
+    }),
+  f('urlEncode', { b: 'required', min: 1, max: 1, s: '[teks]', d: 'Encode untuk URL' }, (ctx, [t]) => encodeURIComponent(t)),
+  f('semicolon', { b: 'none', d: 'Karakter ;' }, () => ';'),
+  f('leftBracket', { b: 'none', d: 'Karakter [' }, () => '['),
+  f('rightBracket', { b: 'none', d: 'Karakter ]' }, () => ']'),
+  f('dollar', { b: 'none', d: 'Karakter $' }, () => '$'),
+
+  // ---- Pengecekan -----------------------------------------------------------
+  f('isNumber', { b: 'required', min: 1, max: 1, s: '[teks]', d: 'true/false: apakah angka' },
+    (ctx, [t]) => String(/^-?\d+(\.\d+)?$/.test(t.trim()))),
+  f('checkContains', { b: 'required', min: 2, s: '[teks;cari1;cari2;...]', d: 'true bila teks memuat salah satu kata' },
+    (ctx, [t, ...needles]) => String(needles.some((n) => n !== '' && t.includes(n)))),
+  f('checkCondition', { b: 'required', min: 1, max: 1, lazy: true, s: '[kondisi]', d: 'true/false. Operator: == != > < >= <= && ||' },
+    async (ctx, args, api) => String(await api.cond(args[0]))),
+  f('hasRole', { b: 'required', min: 1, max: 2, s: '[roleID;userID?]', d: 'true/false: member punya role' },
+    async (ctx, [roleId, userId]) => {
+      const m = await ctx.tryMember(userId);
+      return String(!!m?.roles?.cache?.has(cleanId(roleId)));
+    }),
+  f('hasPerms', { b: 'required', min: 1, max: 2, s: '[izin1,izin2;userID?]', d: 'true/false: member punya semua izin (nama izin discord.js)' },
+    async (ctx, [perms, userId]) => {
+      const m = await ctx.tryMember(userId);
+      const p = list(perms);
+      if (!p.length) throw new BotError('Izin belum diisi');
+      return String(!!m?.permissions?.has(p));
+    }),
+  f('isAdmin', { max: 1, s: '[userID?]', d: 'true/false: member administrator' },
+    async (ctx, [userId]) => String(!!(await ctx.tryMember(userId))?.permissions?.has('Administrator'))),
+  f('isOwner', { max: 1, s: '[userID?]', d: 'true/false: user ada di daftar owners bot' },
+    async (ctx, [userId]) => String(ctx.bot.options.owners.includes(has(userId) ? cleanId(userId) : ctx.user?.id))),
+  f('isTrue', { b: 'required', min: 1, max: 1, s: '[teks]', d: 'true bila teks bernilai true/yes/1/on' },
+    (ctx, [t]) => String(truthy(t))),
+];

package/src/functions/vars.js

@@ -0,0 +1,37 @@
+'use strict';
+const { BotError } = require('../errors');
+const { f, has, cleanId } = require('./helpers');
+
+const SCOPES = [
+  ['User', 'user', (ctx) => ctx.user?.id, 'user'],
+  ['Server', 'server', (ctx) => ctx.guild?.id, 'server'],
+  ['Channel', 'channel', (ctx) => ctx.channel?.id, 'channel'],
+];
+
+const out = [];
+for (const [Scope, scope, defaultId, label] of SCOPES) {
+  const idFor = (ctx, id) => {
+    const resolved = has(id) ? cleanId(id) : defaultId(ctx);
+    if (!resolved) throw new BotError(`Tidak ada ${label} pada konteks ini, isi ID secara manual`);
+    return resolved;
+  };
+  out.push(
+    f(`set${Scope}Var`, { b: 'required', min: 2, max: 3, s: `[nama;nilai;${label}ID?]`, d: `Simpan variabel ${label} (harus dideklarasikan dengan bot.variables)` },
+      (ctx, [name, value, id]) => { ctx.bot.setVar(scope, name, value, idFor(ctx, id)); return ''; }),
+    f(`get${Scope}Var`, { b: 'required', min: 1, max: 2, s: `[nama;${label}ID?]`, d: `Baca variabel ${label}` },
+      (ctx, [name, id]) => ctx.bot.getVar(scope, name, idFor(ctx, id))),
+    f(`reset${Scope}Var`, { b: 'required', min: 1, max: 2, s: `[nama;${label}ID?]`, d: `Kembalikan variabel ${label} ke nilai awal` },
+      (ctx, [name, id]) => { ctx.bot.resetVar(scope, name, idFor(ctx, id)); return ''; }),
+  );
+}
+
+out.push(
+  f('setGlobalVar', { b: 'required', min: 2, max: 2, s: '[nama;nilai]', d: 'Simpan variabel global' },
+    (ctx, [name, value]) => { ctx.bot.setVar('global', name, value, null); return ''; }),
+  f('getGlobalVar', { b: 'required', min: 1, max: 1, s: '[nama]', d: 'Baca variabel global' },
+    (ctx, [name]) => ctx.bot.getVar('global', name, null)),
+  f('resetGlobalVar', { b: 'required', min: 1, max: 1, s: '[nama]', d: 'Kembalikan variabel global ke nilai awal' },
+    (ctx, [name]) => { ctx.bot.resetVar('global', name, null); return ''; }),
+);
+
+module.exports = out;

package/src/index.js

@@ -0,0 +1,19 @@
+'use strict';
+const { Bot } = require('./bot');
+const { Database } = require('./database');
+const { Context } = require('./context');
+const { BotError, ParseError, ValidationError } = require('./errors');
+const { parse } = require('./parser');
+const { createRegistry, CATEGORIES } = require('./functions');
+
+module.exports = {
+  Bot,
+  Database,
+  Context,
+  BotError,
+  ParseError,
+  ValidationError,
+  parse,
+  createRegistry,
+  CATEGORIES,
+};

package/src/interpreter.js

@@ -0,0 +1,88 @@
+'use strict';
+const { BotError, Stop } = require('./errors');
+
+// --- Evaluasi kondisi yang aman dari "injeksi operator" -----------------------
+// Hasil fungsi dinamis (mis. $message) ditandai: karakter operator di dalamnya
+// diganti karakter private-use supaya tidak bisa dibaca sebagai operator kondisi.
+const OPS = ['&', '|', '=', '!', '<', '>'];
+const PLACEHOLDERS = OPS.map((_, i) => String.fromCharCode(0xe000 + i));
+
+const escapeOps = (s) => s.replace(/[&|=!<>]/g, (c) => PLACEHOLDERS[OPS.indexOf(c)]);
+const unescapeOps = (s) => s.replace(/[-]/g, (c) => OPS[c.charCodeAt(0) - 0xe000]);
+const isNum = (s) => /^-?\d+(\.\d+)?$/.test(s);
+
+function compare(raw) {
+  const s = raw.trim();
+  const m = /^(.*?)(==|!=|>=|<=|>|<)(.*)$/s.exec(s);
+  if (!m) return unescapeOps(s).trim().toLowerCase() === 'true';
+  const l = unescapeOps(m[1]).trim();
+  const r = unescapeOps(m[3]).trim();
+  const numeric = isNum(l) && isNum(r);
+  const a = numeric ? Number(l) : l;
+  const b = numeric ? Number(r) : r;
+  switch (m[2]) {
+    case '==': return a === b;
+    case '!=': return a !== b;
+    case '>=': return a >= b;
+    case '<=': return a <= b;
+    case '>': return a > b;
+    default: return a < b;
+  }
+}
+
+/** "a==b && c>1 || d!=e" -> boolean. Tanpa kurung. Nilai kosong/lainnya = false. */
+function evalCondition(str) {
+  return str.split('||').some((group) => group.split('&&').every(compare));
+}
+
+class Interpreter {
+  /** Jalankan daftar node, kembalikan teks hasil. */
+  async run(nodes, ctx, opts = {}) {
+    let out = '';
+    for (const node of nodes) {
+      if (node.type === 'text') { out += node.value; continue; }
+      const value = node.type === 'if' ? await this._if(node, ctx) : await this._call(node, ctx);
+      out += opts.cond ? escapeOps(value) : value;
+    }
+    return out;
+  }
+
+  async cond(nodes, ctx) {
+    return evalCondition(await this.run(nodes, ctx, { cond: true }));
+  }
+
+  async _if(node, ctx) {
+    for (const branch of node.branches) {
+      if (branch.cond === null || (await this.cond(branch.cond, ctx))) {
+        return this.run(branch.body, ctx);
+      }
+    }
+    return '';
+  }
+
+  async _call(node, ctx) {
+    const { def } = node;
+    const api = {
+      run: (nodes) => this.run(nodes, ctx),
+      cond: (nodes) => this.cond(nodes, ctx),
+    };
+    try {
+      let result;
+      if (def.lazy) {
+        result = await def.run(ctx, node.args ?? [], api);
+      } else {
+        const args = [];
+        for (const arg of node.args ?? []) args.push(await this.run(arg, ctx));
+        result = await def.run(ctx, args, api);
+      }
+      return result === undefined || result === null ? '' : String(result);
+    } catch (e) {
+      if (e instanceof Stop || (e instanceof BotError && e.fn)) throw e;
+      const err = new BotError(`${def.display}: ${e.message}`, { cause: e });
+      err.fn = def.display;
+      throw err;
+    }
+  }
+}
+
+module.exports = { Interpreter, evalCondition, escapeOps, unescapeOps };