@pmate/cli 0.24.44 → 0.25.1

package/dist/index.d.ts

@@ -571,6 +571,7 @@ type CollectCommandArgs = {
     endpoint?: string;
     thread: string;
     text: string;
+    dryRun: boolean;
 };
 type ChatRoomCommonArgs = {
     type: Command.ChatRoom;

package/dist/index.js

@@ -16179,7 +16179,11 @@ var CollectCommandHandler = class {
       if (!thread) {
         throw new Error(`Thread not found: ${args.thread}`);
       }
-      await this.sendReplyViaConversation(targetPage, thread, args.text);
+      const result = await this.sendReplyViaConversation(targetPage, thread, args.text, args.dryRun);
+      if (args.dryRun) {
+        ui.plain(JSON.stringify({ source: target.sourceKey, thread: thread.name, ...result }, null, 2));
+        return;
+      }
       ui.success("im1 reply sent", { source: target.sourceKey, thread: thread.name });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -16412,14 +16416,15 @@ var CollectCommandHandler = class {
       await session.detach().catch(() => void 0);
     }
   }
-  async sendReplyViaConversation(page, thread, text) {
+  async sendReplyViaConversation(page, thread, text, dryRun) {
     const result = await this.evaluateInPage(
       page,
-      buildSendMessageExpr(thread.conversationId, text)
+      buildSendMessageExpr(thread.conversationId, text, dryRun)
     );
     if (!result?.ok) {
       throw new Error(result?.reason || "Send failed");
     }
+    return result;
   }
 };
 async function archiveMessageImages(rootDir, sourceKey, threadKey, messages2) {
@@ -16674,7 +16679,7 @@ function buildGetMessagesByConversationExpr(conversationId, limit) {
     }
   })()`;
 }
-function buildSendMessageExpr(conversationId, message) {
+function buildSendMessageExpr(conversationId, message, dryRun = false) {
   const escapedConversationId = escapeForJs(conversationId);
   const escapedMessage = escapeForJs(message);
   return `(async function() {
@@ -16690,8 +16695,216 @@ function buildSendMessageExpr(conversationId, message) {
       }
       var type = conversation.get ? conversation.get('type') : null;
       var name = conversation.get ? (conversation.get('name') || conversation.get('id')) : '${escapedConversationId}';
-      await conversation.sendMessage('${escapedMessage}', null, null, [], null, null, null, null, null, null);
-      return { ok: true, name: name, type: type };
+      function normalizeMentionName(value) {
+        return String(value || '')
+          .replace(/\\s+/g, ' ')
+          .replace(/\\u200B/g, '')
+          .trim();
+      }
+      function addLookup(lookup, name, id, label) {
+        var normalized = normalizeMentionName(name);
+        if (!normalized || !id || lookup[normalized]) return;
+        lookup[normalized] = { uid: id, label: normalizeMentionName(label || name) };
+      }
+      function addMentionAliases(lookup, name, id) {
+        var normalized = normalizeMentionName(name);
+        addLookup(lookup, normalized, id, normalized);
+        addLookup(lookup, normalized.replace(/\\s*\\([^)]*\\)\\s*$/g, ''), id, normalized);
+        addLookup(lookup, normalized.replace(/\\s*\\[[^\\]]*\\]\\s*$/g, ''), id, normalized);
+        addLookup(lookup, normalized.replace(/\\s*[\uFF08][^\uFF09]*[\uFF09]\\s*$/g, ''), id, normalized);
+      }
+      function addContactToLookup(lookup, contact) {
+        if (!contact) return;
+        var id = normalizeMentionName(contact && contact.get ? contact.get('id') : contact && contact.id);
+        if (!id) return;
+        addMentionAliases(lookup, contact && contact.get ? contact.get('name') : contact && contact.name, id);
+        addMentionAliases(lookup, contact && contact.get ? contact.get('profileName') : contact && contact.profileName, id);
+        addMentionAliases(lookup, contact && contact.get ? contact.get('title') : contact && contact.title, id);
+      }
+      function buildMentionLookup() {
+        var lookup = {};
+        var all = [];
+        if (controller && typeof controller.getAllPrivateConversations === 'function') {
+          var privates = controller.getAllPrivateConversations();
+          all = privates.models || privates || [];
+        }
+        for (var i = 0; i < all.length; i++) {
+          addContactToLookup(lookup, all[i]);
+        }
+        var memberIds = [];
+        var membersV2 = conversation && conversation.get ? (conversation.get('membersV2') || []) : [];
+        var members = conversation && conversation.get ? (conversation.get('members') || []) : [];
+        for (var j = 0; j < membersV2.length; j++) {
+          memberIds.push(membersV2[j].id || membersV2[j]);
+          addMentionAliases(lookup, membersV2[j].displayName, membersV2[j].id);
+        }
+        for (var k = 0; k < members.length; k++) {
+          memberIds.push(members[k]);
+        }
+        for (var m = 0; m < memberIds.length; m++) {
+          var memberContact = controller.get(memberIds[m]);
+          if (memberContact) addContactToLookup(lookup, memberContact);
+        }
+        return lookup;
+      }
+      function normalizeMentionKey(value) {
+        return normalizeMentionName(value)
+          .replace(/^@+/, '')
+          .replace(/\\s*\\([^)]*\\)\\s*$/g, '')
+          .replace(/\\s*\\[[^\\]]*\\]\\s*$/g, '')
+          .replace(/\\s*[\uFF08][^\uFF09]*[\uFF09]\\s*$/g, '')
+          .toLowerCase()
+          .replace(/[^\\p{L}\\p{N}]+/gu, ' ')
+          .trim();
+      }
+      function hasWordBoundary(text, end) {
+        return end >= text.length || !/[\\p{L}\\p{N}_]/u.test(text[end]);
+      }
+      function readMentionQuery(text, atIndex) {
+        var start = atIndex + 1;
+        var end = start;
+        while (end < text.length && /[\\p{L}\\p{N}_-]/u.test(text[end])) {
+          end += 1;
+        }
+        if (end === start) return null;
+        return { raw: text.slice(start, end), start: atIndex, end: end };
+      }
+      function resolveFuzzyMention(query, lookup) {
+        var queryKey = normalizeMentionKey(query);
+        if (!queryKey) return { uid: null, reason: 'empty-query', candidates: [] };
+        var scoresByUid = {};
+        var labelsByUid = {};
+        var aliases = Object.keys(lookup);
+        for (var i = 0; i < aliases.length; i++) {
+          var alias = aliases[i];
+          var aliasKey = normalizeMentionKey(alias);
+          if (!aliasKey) continue;
+          var score = 0;
+          var aliasTokens = aliasKey.split(' ');
+          if (aliasKey === queryKey) score = 100;
+          else if (aliasTokens.indexOf(queryKey) !== -1) score = 80;
+          else if (aliasKey.indexOf(queryKey) !== -1) score = 60;
+          else if (queryKey.indexOf(aliasKey) !== -1) score = 40;
+          if (score === 0) continue;
+          var entry = lookup[alias];
+          var uid = entry.uid;
+          if (!scoresByUid[uid] || score > scoresByUid[uid]) {
+            scoresByUid[uid] = score;
+            labelsByUid[uid] = entry.label || alias;
+          }
+        }
+        var bestUid = null;
+        var bestScore = 0;
+        var bestCount = 0;
+        var uids = Object.keys(scoresByUid);
+        var candidates = uids.map(function(uid) {
+          return { uid: uid, name: labelsByUid[uid], score: scoresByUid[uid] };
+        }).sort(function(a, b) { return b.score - a.score || String(a.name || '').localeCompare(String(b.name || '')); });
+        for (var j = 0; j < uids.length; j++) {
+          var uidScore = scoresByUid[uids[j]];
+          if (uidScore > bestScore) {
+            bestUid = uids[j];
+            bestScore = uidScore;
+            bestCount = 1;
+          } else if (uidScore === bestScore) {
+            bestCount += 1;
+          }
+        }
+        if (!bestUid) return { uid: null, reason: 'no-match', candidates: candidates.slice(0, 5) };
+        if (bestCount !== 1) return { uid: null, reason: 'ambiguous', candidates: candidates.slice(0, 5) };
+        return { uid: bestUid, label: labelsByUid[bestUid], reason: 'matched', candidates: candidates.slice(0, 5) };
+      }
+      function extractMentions(text) {
+        var lookup = buildMentionLookup();
+        var names = Object.keys(lookup).sort(function(a, b) { return b.length - a.length; });
+        var replacements = [];
+        var debug = [];
+        var occupied = [];
+        function overlaps(start, end) {
+          for (var i = 0; i < occupied.length; i++) {
+            if (start < occupied[i].end && end > occupied[i].start) return true;
+          }
+          return false;
+        }
+        var atIndex = 0;
+        while (atIndex < text.length) {
+          var idx = text.indexOf('@', atIndex);
+          if (idx === -1) break;
+          if (overlaps(idx, idx + 1)) {
+            atIndex = idx + 1;
+            continue;
+          }
+          var matched = null;
+          var debugItem = { raw: null, start: idx, matched: false, reason: 'not-parsed', uid: null, candidates: [] };
+          for (var i = 0; i < names.length; i++) {
+            var mentionText = '@' + names[i];
+            if (text.slice(idx, idx + mentionText.length) === mentionText && hasWordBoundary(text, idx + mentionText.length)) {
+              var entry = lookup[names[i]];
+              matched = { uid: entry.uid, label: entry.label || names[i], start: idx, end: idx + mentionText.length };
+              debugItem = { raw: mentionText, start: idx, matched: true, reason: 'exact', uid: matched.uid, replacement: '@' + matched.label, candidates: [{ uid: matched.uid, name: matched.label, score: 100 }] };
+              break;
+            }
+          }
+          if (!matched) {
+            var query = readMentionQuery(text, idx);
+            if (query) {
+              var fuzzy = resolveFuzzyMention(query.raw, lookup);
+              debugItem = { raw: '@' + query.raw, start: query.start, matched: !!fuzzy.uid, reason: fuzzy.reason, uid: fuzzy.uid, replacement: fuzzy.label ? '@' + fuzzy.label : null, candidates: fuzzy.candidates };
+              if (fuzzy.uid) {
+                matched = { uid: fuzzy.uid, label: fuzzy.label || query.raw, start: query.start, end: query.end };
+              }
+            }
+          }
+          if (matched && !overlaps(matched.start, matched.end)) {
+            replacements.push({ uid: matched.uid, label: matched.label, start: matched.start, end: matched.end });
+            occupied.push({ start: matched.start, end: matched.end });
+            debugItem.matched = true;
+            debugItem.uid = matched.uid;
+            debugItem.replacement = '@' + matched.label;
+            atIndex = matched.end;
+          } else {
+            atIndex = idx + 1;
+          }
+          debug.push(debugItem);
+        }
+        replacements.sort(function(a, b) { return a.start - b.start; });
+        var finalText = '';
+        var mentions = [];
+        var cursor = 0;
+        for (var r = 0; r < replacements.length; r++) {
+          var replacement = '@' + replacements[r].label;
+          finalText += text.slice(cursor, replacements[r].start);
+          var finalStart = finalText.length;
+          finalText += replacement;
+          mentions.push({ uid: replacements[r].uid, start: finalStart, length: replacement.length, type: 0 });
+          cursor = replacements[r].end;
+        }
+        finalText += text.slice(cursor);
+        mentions.sort(function(a, b) { return a.start - b.start; });
+        return { message: finalText, mentions: mentions, debug: debug, lookupSize: names.length };
+      }
+      var plan = extractMentions('${escapedMessage}');
+      var mentions = plan.mentions;
+      var mentionTarget = mentions.length > 0 ? mentions[0].uid : null;
+      var mentionsArg = mentions.length > 0 ? mentions : null;
+      if (${dryRun ? "true" : "false"}) {
+        return {
+          ok: true,
+          dryRun: true,
+          conversationId: '${escapedConversationId}',
+          inputMessage: '${escapedMessage}',
+          message: plan.message,
+          name: name,
+          type: type,
+          mentionTarget: mentionTarget,
+          mentions: mentions,
+          mentionCount: mentions.length,
+          mentionDebug: plan.debug,
+          mentionLookupSize: plan.lookupSize
+        };
+      }
+      await conversation.sendMessage(plan.message, mentionTarget, mentionsArg, [], null, null, null, null, null, null);
+      return { ok: true, name: name, type: type, mentionCount: mentions.length };
     } catch(e) {
       return { ok: false, reason: e && e.message ? e.message : String(e) };
     }
@@ -25219,6 +25432,7 @@ function parseIm1ReplyArgs(tokens) {
   const targetTokens = [];
   let thread;
   let text;
+  let dryRun = false;
   while (rest.length > 0) {
     const token = rest.shift();
     switch (token) {
@@ -25228,6 +25442,10 @@ function parseIm1ReplyArgs(tokens) {
       case "--text":
         text = requireValue11(rest, token);
         break;
+      case "--dryrun":
+      case "--dry-run":
+        dryRun = true;
+        break;
       case "--source":
       case "--endpoint":
         targetTokens.push(token, requireValue11(rest, token));
@@ -25249,7 +25467,8 @@ function parseIm1ReplyArgs(tokens) {
     source: target.source,
     endpoint: target.endpoint,
     thread,
-    text
+    text,
+    dryRun
   };
 }
 function parseTargetOptions(tokens) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/cli",
-  "version": "0.24.44",
+  "version": "0.25.1",
   "description": "CLI utilities for the pMate project",
   "license": "MIT",
   "bin": {