@shoru/kitten 0.0.6 → 0.1.1

package/src/plugins/handlers.js

@@ -1,85 +1,122 @@
-import { formatter } from '#formatter.js';
-import { getBucket } from './registry.js';
-import { test } from './matcher.js';
-import { handleError } from './handle-error.js';
-
-export function createHandler(event, sock, isDestroyed, execute) {
-  const bucket = getBucket(event);
-
-  const dispatch = (ctx) => {
-    if (isDestroyed() || !ctx) return;
-
-    // Execute auto-triggered plugins
-    for (const [id, plugin] of bucket.auto) {
-      execute(id, plugin, sock, ctx, event, null);
-    }
-
-    // Execute pattern-matched plugins
-    if (bucket.match.size && ctx.body) {
-      for (const [id, plugin] of bucket.match) {
-        const matchers = plugin._meta?.matchers;
-        if (!matchers) continue;
-
-        const result = test(matchers, ctx.body);
-        if (result) {
-          execute(id, plugin, sock, ctx, event, result);
-        }
-      }
-    }
-  };
-
-  switch (event) {
-    case 'messages.upsert':
-      return ({ messages, type }) => {
-        if (type !== 'notify') return;
-
-        for (const msg of messages) {
-          if (!msg?.key?.remoteJid || msg.key.remoteJid === 'status@broadcast') {
-            continue;
-          }
-
-          try {
-            dispatch(formatter(sock, msg, event));
-          } catch (err) {
-            handleError('[PluginManager] Format error:', err);
-          }
-        }
-      };
-
-    case 'messages.update':
-      return (updates) => {
-        for (const { key, update } of updates) {
-          if (key?.remoteJid) {
-            dispatch({ key, update, jid: key.remoteJid });
-          }
-        }
-      };
-
-    case 'messages.reaction':
-      return (reactions) => {
-        for (const { key, reaction } of reactions) {
-          if (key?.remoteJid) {
-            dispatch({
-              key,
-              reaction,
-              jid: key.remoteJid,
-              emoji: reaction?.text
-            });
-          }
-        }
-      };
-
-    case 'group-participants.update':
-    case 'connection.update':
-      return (update) => dispatch(update);
-
-    case 'creds.update':
-      return (creds) => dispatch({ creds });
-
-    case 'call':
-      return (calls) => calls.forEach(c => dispatch(c));
-
-    default:
-      return (data) => dispatch({ data });
-  }
+import { formatter } from '#formatter.js';
+import { getBucket } from './registry.js';
+import { handleError } from './handle-error.js';
+
+export function createHandler(event, sock, isDestroyed, execute) {
+  const bucket = getBucket(event);
+
+  const dispatch = (ctx) => {
+    if (isDestroyed() || !ctx) return;
+
+    // 1. Execute auto-triggered plugins
+    if (bucket.auto.size > 0) {
+      for (const [id, plugin] of bucket.auto) {
+        execute(id, plugin, sock, ctx, event, null);
+      }
+    }
+
+    // 2. Execute pattern-matched plugins
+    if (bucket.allMatch.size > 0 && ctx.body) {
+      const trimmed = ctx.body.trim();
+      if (!trimmed) return;
+      const lower = trimmed.toLowerCase();
+      const spaceIdx = lower.indexOf(' ');
+      const firstToken = spaceIdx < 0 ? lower : lower.slice(0, spaceIdx);
+
+      const executedIds = new Set();
+
+      // Fast O(1) command lookup (e.g. "!tst")
+      const matchedCommands = bucket.commandMap.get(firstToken);
+      if (matchedCommands) {
+        for (const item of matchedCommands) {
+          executedIds.add(item.id);
+          execute(item.id, item.plugin, sock, ctx, event, { match: item.match, prefix: item.prefix });
+        }
+      }
+
+      // Fast prefixless command lookup (plugins with prefix: false)
+      if (bucket.prefixlessMap.size > 0) {
+        const matchedPrefixless = bucket.prefixlessMap.get(firstToken);
+        if (matchedPrefixless) {
+          for (const item of matchedPrefixless) {
+            if (!executedIds.has(item.id)) {
+              executedIds.add(item.id);
+              execute(item.id, item.plugin, sock, ctx, event, { match: item.match, prefix: null });
+            }
+          }
+        }
+      }
+
+      // Execute regex plugins if any exist
+      if (bucket.regexList.size > 0) {
+        for (const [id, item] of bucket.regexList) {
+          if (executedIds.has(id)) continue;
+          for (const re of item.regexes) {
+            re.lastIndex = 0;
+            const m = re.exec(ctx.body);
+            if (m) {
+              executedIds.add(id);
+              execute(id, item.plugin, sock, ctx, event, { match: m, prefix: null });
+              break;
+            }
+          }
+        }
+      }
+    }
+  };
+
+  switch (event) {
+    case 'messages.upsert':
+      return ({ messages, type }) => {
+        if (type !== 'notify') return;
+
+        for (const msg of messages) {
+          if (!msg?.key?.remoteJid || msg.key.remoteJid === 'status@broadcast') {
+            continue;
+          }
+
+          try {
+            dispatch(formatter(sock, msg, event));
+          } catch (err) {
+            handleError('[PluginManager] Format error:', err);
+          }
+        }
+      };
+
+    case 'messages.update':
+      return (updates) => {
+        for (const { key, update } of updates) {
+          if (key?.remoteJid) {
+            dispatch({ key, update, jid: key.remoteJid });
+          }
+        }
+      };
+
+    case 'messages.reaction':
+      return (reactions) => {
+        for (const { key, reaction } of reactions) {
+          if (key?.remoteJid) {
+            dispatch({
+              key,
+              reaction,
+              jid: key.remoteJid,
+              emoji: reaction?.text,
+            });
+          }
+        }
+      };
+
+    case 'group-participants.update':
+    case 'connection.update':
+      return (update) => dispatch(update);
+
+    case 'creds.update':
+      return (creds) => dispatch({ creds });
+
+    case 'call':
+      return (calls) => calls.forEach((c) => dispatch(c));
+
+    default:
+      return (data) => dispatch({ data });
+  }
 }

package/src/plugins/loader.js

@@ -11,18 +11,20 @@ import { setPlugin, registerToBuckets } from './registry.js';
 const fileLocks = new Map();
 
 export function getLock(filePath) {
-  let lock = fileLocks.get(filePath);
+  const resolved = path.resolve(filePath);
+  let lock = fileLocks.get(resolved);
   if (!lock) {
     lock = new Mutex();
-    fileLocks.set(filePath, lock);
+    fileLocks.set(resolved, lock);
   }
   return lock;
 }
 
 export function deleteLockIfUnused(filePath) {
-  const lock = fileLocks.get(filePath);
+  const resolved = path.resolve(filePath);
+  const lock = fileLocks.get(resolved);
   if (lock && !lock.isLocked()) {
-    fileLocks.delete(filePath);
+    fileLocks.delete(resolved);
   }
 }
 
@@ -31,7 +33,8 @@ export function clearLocks() {
 }
 
 export function getParentFolder(dirPath) {
-  return path.relative(PLUGIN_DIR, dirPath).split(path.sep)[0] || null;
+  const rel = path.relative(PLUGIN_DIR, path.resolve(dirPath));
+  return rel ? rel.split(/[\\/]/)[0] : null;
 }
 
 function normalize(value) {
@@ -46,25 +49,27 @@ function normalize(value) {
 }
 
 export async function loadFile(filePath, parent, shouldRegister = true) {
+  const resolvedPath = path.resolve(filePath);
   const execute = async () => {
-    const { mtimeMs } = await fs.stat(filePath);
-    const mod = await import(`${pathToFileURL(filePath)}?v=${Math.trunc(mtimeMs)}`);
+    const { mtimeMs } = await fs.stat(resolvedPath);
+    const mod = await import(`${pathToFileURL(resolvedPath)}?v=${Math.trunc(mtimeMs)}`);
     const loaded = new Map();
 
     for (const [name, value] of Object.entries(mod)) {
       const plugin = normalize(value);
       if (!plugin || plugin.enabled === false) continue;
 
-      const id = path.relative(PLUGIN_DIR, filePath)
+      const id = path.relative(PLUGIN_DIR, resolvedPath)
         .replace(/\.[jt]s$/, '')
-        .replaceAll(path.sep, '/') + ':' + name;
+        .replaceAll(path.sep, '/')
+        .replaceAll('\\', '/') + ':' + name;
 
       const events = (Array.isArray(plugin.events) ? plugin.events : [])
         .filter(e => EVENTS.has(e));
 
       plugin._meta = {
         parent,
-        filePath,
+        filePath: resolvedPath,
         id,
         events: events.length ? events : [defaultEvent],
         matchers: compile(plugin.match, plugin.prefix),
@@ -82,7 +87,7 @@ export async function loadFile(filePath, parent, shouldRegister = true) {
   };
 
   return shouldRegister
-    ? getLock(filePath).runExclusive(execute)
+    ? getLock(resolvedPath).runExclusive(execute)
     : execute();
 }
 
@@ -101,9 +106,10 @@ export async function loadAll() {
       !e.name.startsWith('_')
     )
     .map(e => {
-      const dirPath = e.parentPath ?? e.path;
+      const dirPath = e.parentPath ?? e.path ?? PLUGIN_DIR;
+      const fullPath = path.resolve(dirPath, e.name);
       return {
-        path: path.join(dirPath, e.name),
+        path: fullPath,
         parent: getParentFolder(dirPath)
       };
     });

package/src/plugins/matcher.js

@@ -1,59 +1,78 @@
-import { PREFIXES } from './config.js';
-
-export function compile(match, prefixOpt = PREFIXES) {
-  if (!Array.isArray(match) || !match.length) return null;
-
-  const strings = match
-    .filter(m => typeof m === 'string')
-    .map(s => s.toLowerCase());
-
-  const regexes = match.filter(m => m instanceof RegExp);
-
-  const prefixes = prefixOpt === false
-    ? null
-    : new Set([prefixOpt ?? PREFIXES].flat());
-
-  return {
-    strings,
-    set: strings.length ? new Set(strings) : null,
-    regexes,
-    prefixes,
-  };
-}
-
-export function test(matchers, body) {
-  if (!body || typeof body !== 'string') return null;
-
-  const text = body.toLowerCase();
-
-  if (matchers.set) {
-    const prefix = text[0];
-    const prefixValid = !matchers.prefixes || matchers.prefixes.has(prefix);
-
-    if (prefixValid) {
-      const rest = text.slice(1);
-      const idx = rest.indexOf(' ');
-      const cmd = idx < 0 ? rest : rest.slice(0, idx);
-
-      if (cmd) {
-        if (matchers.set.has(cmd)) {
-          return { match: cmd, prefix };
-        }
-
-        for (const s of matchers.strings) {
-          if (cmd.length > s.length && cmd.startsWith(s)) {
-            return { match: s, prefix };
-          }
-        }
-      }
-    }
-  }
-
-  for (const re of matchers.regexes) {
-    re.lastIndex = 0;
-    const m = re.exec(body);
-    if (m) return { match: m, prefix: null };
-  }
-
-  return null;
+import { PREFIXES } from './config.js';
+
+export function compile(match, prefixOpt = PREFIXES) {
+  if (!Array.isArray(match) || !match.length) return null;
+
+  const strings = match
+    .filter(m => typeof m === 'string')
+    .map(s => s.trim().toLowerCase())
+    .filter(Boolean);
+
+  const regexes = match.filter(m => m instanceof RegExp);
+
+  if (!strings.length && !regexes.length) return null;
+
+  const prefixes = prefixOpt === false
+    ? null
+    : new Set([prefixOpt ?? PREFIXES].flat().map(p => (typeof p === 'string' ? p.trim().toLowerCase() : p)));
+
+  return {
+    strings,
+    set: strings.length ? new Set(strings) : null,
+    regexes,
+    prefixes,
+    hasPrefix: prefixOpt !== false,
+  };
+}
+
+export function test(matchers, body) {
+  if (!body || typeof body !== 'string') return null;
+
+  const trimmed = body.trim();
+  if (!trimmed) return null;
+  const text = trimmed.toLowerCase();
+
+  if (matchers.set) {
+    if (matchers.prefixes) {
+      const prefix = text[0];
+      if (matchers.prefixes.has(prefix)) {
+        const rest = text.slice(1);
+        const idx = rest.indexOf(' ');
+        const cmd = idx < 0 ? rest : rest.slice(0, idx);
+
+        if (cmd) {
+          if (matchers.set.has(cmd)) {
+            return { match: cmd, prefix };
+          }
+
+          for (const s of matchers.strings) {
+            if (cmd.length > s.length && cmd.startsWith(s)) {
+              return { match: s, prefix };
+            }
+          }
+        }
+      }
+    } else {
+      const idx = text.indexOf(' ');
+      const cmd = idx < 0 ? text : text.slice(0, idx);
+      if (cmd) {
+        if (matchers.set.has(cmd)) {
+          return { match: cmd, prefix: null };
+        }
+        for (const s of matchers.strings) {
+          if (cmd.length > s.length && cmd.startsWith(s)) {
+            return { match: s, prefix: null };
+          }
+        }
+      }
+    }
+  }
+
+  for (const re of matchers.regexes) {
+    re.lastIndex = 0;
+    const m = re.exec(body);
+    if (m) return { match: m, prefix: null };
+  }
+
+  return null;
 }