@pinet/pinet-core 0.1.2 → 0.2.1

package/dist/pinet-read-formatting.js

@@ -1,10 +1,29 @@
 import { classifyPinetMail, formatPinetMailClassLabel, } from "@pinet/broker-core/mail-classification";
-function truncateText(value, maxLength = 180) {
+const COMPACT_READ_DETAIL_LIMIT = 10;
+const COMPACT_READ_TEXT_MESSAGE_LIMIT = 3;
+const COMPACT_READ_PREVIEW_LENGTH = 96;
+function truncateText(value, maxLength = COMPACT_READ_PREVIEW_LENGTH) {
     const collapsed = value.replace(/\s+/g, " ").trim();
     if (collapsed.length <= maxLength)
         return collapsed;
     return `${collapsed.slice(0, Math.max(0, maxLength - 1))}…`;
 }
+function classifyReadMessage(item) {
+    return classifyPinetMail({
+        source: item.message.source,
+        threadId: item.message.threadId,
+        sender: item.message.sender,
+        body: item.message.body,
+        metadata: item.message.metadata,
+    }).class;
+}
+function formatCompactMessagePreview(item) {
+    const label = formatPinetMailClassLabel(classifyReadMessage(item));
+    return `- [${label}] [${item.message.source}/${item.message.threadId} #${item.message.id}] ${item.message.sender}: ${truncateText(item.message.body)}`;
+}
+function isMessageBodyTruncated(item) {
+    return truncateText(item.message.body) !== item.message.body.replace(/\s+/g, " ").trim();
+}
 export function formatPinetReadResultFull(result, options) {
     const scope = options.threadId ? `thread ${options.threadId}` : "your Pinet inbox";
     const mode = options.unreadOnly === false ? "latest" : "unread";
@@ -15,20 +34,13 @@ export function formatPinetReadResultFull(result, options) {
     if (result.messages.length > 0) {
         lines.push("");
         for (const item of result.messages) {
-            const classification = classifyPinetMail({
-                source: item.message.source,
-                threadId: item.message.threadId,
-                sender: item.message.sender,
-                body: item.message.body,
-                metadata: item.message.metadata,
-            });
-            const label = formatPinetMailClassLabel(classification.class);
+            const label = formatPinetMailClassLabel(classifyReadMessage(item));
             lines.push(`- [${label}] [${item.message.source}/${item.message.threadId} #${item.message.id}] ${item.message.sender}: ${item.message.body}`);
         }
     }
     if (result.unreadThreads.length > 0) {
         lines.push("", "Unread thread pointers:");
-        for (const thread of result.unreadThreads.slice(0, 10)) {
+        for (const thread of result.unreadThreads.slice(0, COMPACT_READ_DETAIL_LIMIT)) {
             const label = formatPinetMailClassLabel(thread.highestMailClass);
             const counts = summarizeUnreadThreadCounts(thread);
             lines.push(`- [${label}] ${thread.threadId} (${thread.source}${thread.channel ? `/${thread.channel}` : ""}): ${thread.unreadCount} unread${counts ? ` (${counts})` : ""}; latest #${thread.latestMessageId}; pointer=pinet action=read args.thread_id=${thread.threadId} args.unread_only=true`);
@@ -51,38 +63,54 @@ export function summarizeUnreadThreadCounts(thread) {
         .join(", ");
 }
 export function buildCompactPinetReadDetails(result) {
-    return {
+    const messages = result.messages.slice(0, COMPACT_READ_DETAIL_LIMIT);
+    const unreadThreads = result.unreadThreads.slice(0, COMPACT_READ_DETAIL_LIMIT);
+    const messageTruncated = Math.max(0, result.messages.length - messages.length);
+    const unreadThreadTruncated = Math.max(0, result.unreadThreads.length - unreadThreads.length);
+    const summaryParts = [
+        `${result.messages.length} msg`,
+        `unread ${result.unreadCountBefore}→${result.unreadCountAfter}`,
+        result.markedReadIds.length > 0 ? `marked ${result.markedReadIds.length}` : null,
+        result.unreadThreads.length > 0
+            ? `${result.unreadThreads.length} unread thread${result.unreadThreads.length === 1 ? "" : "s"}`
+            : null,
+    ].filter((item) => Boolean(item));
+    const details = {
+        summary: summaryParts.join("; "),
         messageCount: result.messages.length,
-        unreadCountBefore: result.unreadCountBefore,
-        unreadCountAfter: result.unreadCountAfter,
-        markedReadIds: result.markedReadIds,
-        messages: result.messages.map((item) => {
-            const classification = classifyPinetMail({
-                source: item.message.source,
-                threadId: item.message.threadId,
-                sender: item.message.sender,
-                body: item.message.body,
-                metadata: item.message.metadata,
-            });
-            return {
-                inboxId: item.inboxId,
-                messageId: item.message.id,
-                threadId: item.message.threadId,
-                source: item.message.source,
-                sender: item.message.sender,
-                class: classification.class,
-                preview: truncateText(item.message.body),
-            };
-        }),
-        unreadThreads: result.unreadThreads.slice(0, 10).map((thread) => ({
+        unreadBefore: result.unreadCountBefore,
+        unreadAfter: result.unreadCountAfter,
+    };
+    if (result.markedReadIds.length > 0) {
+        details.markedReadCount = result.markedReadIds.length;
+    }
+    if (messages.length > 0) {
+        details.messages = messages.map((item) => ({
+            id: item.message.id,
+            threadId: item.message.threadId,
+            source: item.message.source,
+            sender: item.message.sender,
+            class: classifyReadMessage(item),
+        }));
+        details.exactBodies = "args.full=true args.unread_only=false";
+    }
+    if (messageTruncated > 0) {
+        details.messagesTruncated = messageTruncated;
+    }
+    if (unreadThreads.length > 0) {
+        details.unreadThreads = unreadThreads.map((thread) => ({
             threadId: thread.threadId,
             source: thread.source,
-            unreadCount: thread.unreadCount,
+            unread: thread.unreadCount,
             latestMessageId: thread.latestMessageId,
-            highestMailClass: thread.highestMailClass,
-            mailClassSummary: summarizeUnreadThreadCounts(thread),
-        })),
-    };
+            class: thread.highestMailClass,
+            summary: summarizeUnreadThreadCounts(thread),
+        }));
+    }
+    if (unreadThreadTruncated > 0) {
+        details.unreadThreadsTruncated = unreadThreadTruncated;
+    }
+    return details;
 }
 export function formatPinetReadResultCompact(result, options) {
     const mode = options.unreadOnly === false ? "latest" : "unread";
@@ -90,5 +118,26 @@ export function formatPinetReadResultCompact(result, options) {
     const unreadThreadSuffix = result.unreadThreads.length > 0
         ? `; ${result.unreadThreads.length} unread thread${result.unreadThreads.length === 1 ? "" : "s"}`
         : "";
-    return `Pinet read: ${result.messages.length} ${mode} message${result.messages.length === 1 ? "" : "s"}; unread ${result.unreadCountBefore}→${result.unreadCountAfter}${markedSuffix}${unreadThreadSuffix}.`;
+    const lines = [
+        `Pinet read: ${result.messages.length} ${mode} message${result.messages.length === 1 ? "" : "s"}; unread ${result.unreadCountBefore}→${result.unreadCountAfter}${markedSuffix}${unreadThreadSuffix}.`,
+    ];
+    // Show capped per-message previews for both thread-scoped and inbox-wide
+    // compact reads. Restricting previews to thread-scoped reads (the previous
+    // behavior) left inbox-wide `pinet action=read` callers with only the counts
+    // header, which pushed agents toward `full=true` just to see what arrived.
+    // The 3-message + 96-char cap already keeps the output bounded.
+    if (result.messages.length > 0) {
+        const shownMessages = result.messages.slice(0, COMPACT_READ_TEXT_MESSAGE_LIMIT);
+        lines.push(...shownMessages.map(formatCompactMessagePreview));
+        const truncated = result.messages.length - shownMessages.length;
+        if (truncated > 0) {
+            lines.push(`… ${truncated} more message${truncated === 1 ? "" : "s"}.`);
+        }
+        if (truncated > 0 || shownMessages.some(isMessageBodyTruncated)) {
+            // Stated as a diagnostic affordance rather than a directive so we don't
+            // actively push routine reads toward `full=true`.
+            lines.push("args.full=true args.unread_only=false returns verbatim bodies.");
+        }
+    }
+    return lines.join("\n");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinet/pinet-core",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "type": "module",
   "description": "Pinet runtime core for pi — broker/follower orchestration and mesh tooling",
   "author": "Will Porcellini <5994936+gugu91@users.noreply.github.com>",
@@ -35,8 +35,8 @@
     "test": "vitest run *.test.ts"
   },
   "dependencies": {
-    "@pinet/broker-core": "0.1.2",
-    "@pinet/transport-core": "0.1.2"
+    "@pinet/broker-core": "0.2.1",
+    "@pinet/transport-core": "0.2.1"
   },
   "types": "./dist/index.d.ts"
 }