@jitsusama/agentic-harness.core 0.1.0

package/dist/slack/content-gate.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The Slack content gate: a thin adapter over the shared loop
+ * breaker in lib/gate. It supplies the Slack-specific detection,
+ * block formatting and relent wording; the block-first,
+ * relent-on-repeat mechanism lives in decideGate so prose,
+ * sections and Slack share one behaviour.
+ */
+import { type GateDecision } from "../gate/index.js";
+/** The gate's verdict on one Slack message body. */
+export type SlackGateDecision = GateDecision;
+/** Decide whether to block, relent or allow given prior block signatures. */
+export declare function slackGateDecision(text: string, priorSignatures: string[]): SlackGateDecision;

package/dist/slack/content-gate.js

@@ -0,0 +1,22 @@
+/**
+ * The Slack content gate: a thin adapter over the shared loop
+ * breaker in lib/gate. It supplies the Slack-specific detection,
+ * block formatting and relent wording; the block-first,
+ * relent-on-repeat mechanism lives in decideGate so prose,
+ * sections and Slack share one behaviour.
+ */
+import { decideGate } from "../gate/index.js";
+import { formatSlackBlock } from "./block-message.js";
+import { detectSlackViolations } from "./detect.js";
+const RELENT_PREFIX = [
+    "This Slack message still has formatting the converter cannot",
+    "render after a previous attempt, so it is being let through",
+    "rather than blocked again. Review the remaining problems",
+    "yourself:",
+    "",
+].join("\n");
+/** Decide whether to block, relent or allow given prior block signatures. */
+export function slackGateDecision(text, priorSignatures) {
+    const violations = detectSlackViolations(text);
+    return decideGate(violations, priorSignatures, formatSlackBlock, RELENT_PREFIX, text);
+}

package/dist/slack/detect.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Slack content detection: finds markdown the Slack converter
+ * cannot render as the author intended, so a gate can block and
+ * point the author at the slack-guide skill. Each flagged
+ * construct requires guessing the author's intent to translate
+ * (which cells are headers, which lines are list items, where to
+ * upload an image), so the gate refuses rather than guess. The
+ * silent dialect translations in blocks.ts stay silent; this is
+ * only for the cases that genuinely need the author's hand.
+ *
+ * Detection is deliberately conservative. A malformed list is
+ * flagged only as a run of two or more lines, and a pipe table
+ * only on a separator row or two adjacent pipe rows, so a lone
+ * dash-led sentence or an inline `a | b` is never mistaken for
+ * structure. A missed case is a missed block; a false block on
+ * the high-volume Slack surface is far more corrosive.
+ */
+import type { Violation } from "../gate/index.js";
+/** A single Slack content violation. */
+export interface SlackViolation extends Violation {
+    readonly kind: "slack-image" | "slack-table" | "slack-list" | "slack-glyph-bullet";
+    /** A representative offending snippet. */
+    readonly found: string;
+    /** A short statement of the rule, for the block message. */
+    readonly rule: string;
+}
+/**
+ * Detect Slack content the converter cannot render as intended:
+ * image embeds, pipe tables and malformed lists.
+ */
+export declare function detectSlackViolations(text: string): SlackViolation[];

package/dist/slack/detect.js

@@ -0,0 +1,125 @@
+/**
+ * Slack content detection: finds markdown the Slack converter
+ * cannot render as the author intended, so a gate can block and
+ * point the author at the slack-guide skill. Each flagged
+ * construct requires guessing the author's intent to translate
+ * (which cells are headers, which lines are list items, where to
+ * upload an image), so the gate refuses rather than guess. The
+ * silent dialect translations in blocks.ts stay silent; this is
+ * only for the cases that genuinely need the author's hand.
+ *
+ * Detection is deliberately conservative. A malformed list is
+ * flagged only as a run of two or more lines, and a pipe table
+ * only on a separator row or two adjacent pipe rows, so a lone
+ * dash-led sentence or an inline `a | b` is never mistaken for
+ * structure. A missed case is a missed block; a false block on
+ * the high-volume Slack surface is far more corrosive.
+ */
+const IMAGE_RULE = "slack-guide: Slack does not render markdown image embeds; upload the image with upload_file instead.";
+const TABLE_RULE = "slack-guide: send tabular data through the structured table parameter, not a markdown pipe table.";
+const LIST_RULE = "slack-guide: format lists as proper markdown (a bullet then a space, or `N.` ordinals).";
+const GLYPH_LIST_RULE = "slack-guide: write list bullets as `- `, `* ` or `+ ` markers, not a \u2022 glyph; Slack renders glyph bullets as literal text instead of a native list.";
+const FENCE_REGEX = /```[\s\S]*?```/g;
+const INLINE_CODE_REGEX = /`[^`\n]*`/g;
+const IMAGE_REGEX = /!\[[^\]]*\]\([^)\s]+\)/g;
+// A markdown table separator row: pipes and dashes (with optional
+// alignment colons) and nothing else, with at least one run of
+// dashes. This is the unambiguous "I meant a table" signal.
+const TABLE_SEPARATOR = /^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/;
+// A row that opens like a table cell: optional indent, a pipe,
+// some content, another pipe.
+const PIPE_ROW = /^\s*\|.*\|/;
+// A line that opens an ordered list with a paren instead of the
+// dot Slack needs (`1)` rather than `1.`).
+const MALFORMED_ORDERED = /^\s*\d+\)\s+\S/;
+// A bullet marker immediately followed by a non-space. `*` is
+// left out because `*bold*` collides with it; `-` and `+` led
+// runs are the unambiguous malformed-bullet case.
+const MALFORMED_BULLET = /^\s*[-+]\S/;
+// A line that opens with a bullet glyph, a space and content.
+// The leading anchor means the glyph must start the line, so an
+// inline `3 \u00b7 4` is never mistaken for a bullet, and the
+// run-of-two threshold in flagLists leaves a lone glyph line
+// alone. Slack renders these glyphs as literal characters rather
+// than a native rich_text_list, so they need a markdown marker.
+const GLYPH_BULLET = /^\s*[\u2022\u2023\u25E6\u25AA\u00b7]\s+\S/;
+/** Blank out a region so its contents never match a later scan. */
+function blankOut(text, pattern) {
+    return text.replace(pattern, (match) => " ".repeat(match.length));
+}
+/**
+ * Detect Slack content the converter cannot render as intended:
+ * image embeds, pipe tables and malformed lists.
+ */
+export function detectSlackViolations(text) {
+    // Mask code so pipes, dashes and image syntax inside it never
+    // trip the scans.
+    let scan = blankOut(text, FENCE_REGEX);
+    scan = blankOut(scan, INLINE_CODE_REGEX);
+    const violations = [];
+    for (const match of scan.matchAll(IMAGE_REGEX)) {
+        violations.push({ kind: "slack-image", found: match[0], rule: IMAGE_RULE });
+    }
+    const lines = scan.split("\n");
+    flagTables(lines, violations);
+    flagLists(lines, MALFORMED_ORDERED, violations, "slack-list", LIST_RULE);
+    flagLists(lines, MALFORMED_BULLET, violations, "slack-list", LIST_RULE);
+    flagLists(lines, GLYPH_BULLET, violations, "slack-glyph-bullet", GLYPH_LIST_RULE);
+    return violations;
+}
+/**
+ * Flag the first pipe table in the lines: a separator row, or a
+ * run of two adjacent pipe rows. One flag is enough; the block
+ * message tells the author to fix every table, so there is no
+ * need to walk past the first.
+ */
+function flagTables(lines, violations) {
+    let runStart = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (TABLE_SEPARATOR.test(line) && line.includes("|")) {
+            violations.push({
+                kind: "slack-table",
+                found: line.trim(),
+                rule: TABLE_RULE,
+            });
+            return;
+        }
+        if (PIPE_ROW.test(line)) {
+            if (runStart < 0)
+                runStart = i;
+            if (i - runStart >= 1) {
+                violations.push({
+                    kind: "slack-table",
+                    found: lines[runStart].trim(),
+                    rule: TABLE_RULE,
+                });
+                return;
+            }
+        }
+        else {
+            runStart = -1;
+        }
+    }
+}
+/** Flag a run of two or more consecutive lines matching a marker. */
+function flagLists(lines, marker, violations, kind, rule) {
+    let runStart = -1;
+    for (let i = 0; i <= lines.length; i++) {
+        const matches = i < lines.length && marker.test(lines[i]);
+        if (matches) {
+            if (runStart < 0)
+                runStart = i;
+        }
+        else {
+            if (runStart >= 0 && i - runStart >= 2) {
+                violations.push({
+                    kind,
+                    found: lines[runStart].trim(),
+                    rule,
+                });
+            }
+            runStart = -1;
+        }
+    }
+}

package/dist/slack/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Slack library: API client, credential state, renderers,
+ * resolvers and shared types.
+ *
+ * Public entry point for external consumers. The interactive auth
+ * orchestration (`ensureAuthenticated`, the setup wizard) needs a
+ * host's UI and is not here; an adapter builds that from the
+ * pieces `./auth` exports.
+ */
+export * from "./api/index.js";
+export * from "./auth/index.js";
+export { formatSlackBlock } from "./block-message.js";
+export { extractCellText, extractTables, mrkdwnToBlocks, mrkdwnToCell, parseMrkdwnToElements, renderRichTextCell, tableToBlock, } from "./blocks.js";
+export { type SlackGateDecision, slackGateDecision, } from "./content-gate.js";
+export { detectSlackViolations, type SlackViolation } from "./detect.js";
+export * from "./renderers/index.js";
+export * from "./resolvers/index.js";
+export type { Conversation, ConversationKind, MessageTarget, OAuthApp, SlackAttachment, SlackChannel, SlackColumnSetting, SlackFile, SlackMessage, SlackReaction, SlackTable, SlackUser, StoredToken, } from "./types.js";

package/dist/slack/index.js

@@ -0,0 +1,17 @@
+/**
+ * Slack library: API client, credential state, renderers,
+ * resolvers and shared types.
+ *
+ * Public entry point for external consumers. The interactive auth
+ * orchestration (`ensureAuthenticated`, the setup wizard) needs a
+ * host's UI and is not here; an adapter builds that from the
+ * pieces `./auth` exports.
+ */
+export * from "./api/index.js";
+export * from "./auth/index.js";
+export { formatSlackBlock } from "./block-message.js";
+export { extractCellText, extractTables, mrkdwnToBlocks, mrkdwnToCell, parseMrkdwnToElements, renderRichTextCell, tableToBlock, } from "./blocks.js";
+export { slackGateDecision, } from "./content-gate.js";
+export { detectSlackViolations } from "./detect.js";
+export * from "./renderers/index.js";
+export * from "./resolvers/index.js";

package/dist/slack/paths.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Where Slack credentials and cached lookups live on disk.
+ *
+ * Adapter-neutral on purpose, the same reasoning as memory's and
+ * web's own paths: this module is shared library code any adapter
+ * can depend on, so it must not bake in one adapter's brand. A
+ * Claude Code process storing its own Slack token at a path named
+ * after pi would be as wrong as the reverse.
+ *
+ * This is a clean break from pi's own former path
+ * (`~/.pi/agent/slack.json`, `~/.pi/agent/slack/`), not a
+ * migrated one: unlike a browser comparison baseline or a quest
+ * worktree, a stored OAuth token is cheap to lose and easy to
+ * replace, so there is no injectable override here for an adapter
+ * to point at its old location. Re-running the setup flow once is
+ * the whole cost.
+ */
+/** Where the OAuth app and token credentials are stored. */
+export declare function credentialsPath(): string;
+/**
+ * Where resolved user and channel names are cached.
+ *
+ * Cache rather than config: every entry here is a name Slack's API
+ * already answered once and is cheap to ask again, never something
+ * a person edits or that losing would cost them anything but a
+ * refetch.
+ */
+export declare function cacheDir(): string;

package/dist/slack/paths.js

@@ -0,0 +1,46 @@
+/**
+ * Where Slack credentials and cached lookups live on disk.
+ *
+ * Adapter-neutral on purpose, the same reasoning as memory's and
+ * web's own paths: this module is shared library code any adapter
+ * can depend on, so it must not bake in one adapter's brand. A
+ * Claude Code process storing its own Slack token at a path named
+ * after pi would be as wrong as the reverse.
+ *
+ * This is a clean break from pi's own former path
+ * (`~/.pi/agent/slack.json`, `~/.pi/agent/slack/`), not a
+ * migrated one: unlike a browser comparison baseline or a quest
+ * worktree, a stored OAuth token is cheap to lose and easy to
+ * replace, so there is no injectable override here for an adapter
+ * to point at its old location. Re-running the setup flow once is
+ * the whole cost.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** Honours XDG_CONFIG_HOME; falls back to ~/.config per the XDG spec. */
+function xdgConfigRoot() {
+    const override = process.env.XDG_CONFIG_HOME;
+    return override && override.length > 0
+        ? override
+        : join(homedir(), ".config");
+}
+/** Honours XDG_CACHE_HOME; falls back to ~/.cache per the XDG spec. */
+function xdgCacheRoot() {
+    const override = process.env.XDG_CACHE_HOME;
+    return override && override.length > 0 ? override : join(homedir(), ".cache");
+}
+/** Where the OAuth app and token credentials are stored. */
+export function credentialsPath() {
+    return join(xdgConfigRoot(), "agentic-harness", "slack", "credentials.json");
+}
+/**
+ * Where resolved user and channel names are cached.
+ *
+ * Cache rather than config: every entry here is a name Slack's API
+ * already answered once and is cheap to ask again, never something
+ * a person edits or that losing would cost them anything but a
+ * refetch.
+ */
+export function cacheDir() {
+    return join(xdgCacheRoot(), "agentic-harness", "slack");
+}

package/dist/slack/renderers/channel.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Format channel info as readable text.
+ */
+import type { SlackChannel } from "../types.js";
+/** Render channel info as a readable summary. */
+export declare function renderChannel(ch: SlackChannel): string;

package/dist/slack/renderers/channel.js

@@ -0,0 +1,27 @@
+/**
+ * Format channel info as readable text.
+ */
+/** Render channel info as a readable summary. */
+export function renderChannel(ch) {
+    const lines = [];
+    const flags = [];
+    if (ch.isPrivate)
+        flags.push("private");
+    if (ch.isArchived)
+        flags.push("archived");
+    const suffix = flags.length > 0 ? ` (${flags.join(", ")})` : "";
+    lines.push(`**#${ch.name}**${suffix}`);
+    if (ch.topic)
+        lines.push(`Topic: ${ch.topic}`);
+    if (ch.purpose)
+        lines.push(`Purpose: ${ch.purpose}`);
+    if (ch.memberCount !== undefined) {
+        lines.push(`Members: ${ch.memberCount}`);
+    }
+    if (ch.created) {
+        const date = new Date(ch.created * 1000);
+        lines.push(`Created: ${date.toLocaleDateString()}`);
+    }
+    lines.push(`ID: ${ch.id}`);
+    return lines.join("\n");
+}

package/dist/slack/renderers/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Slack content renderers: markdown formatting for
+ * messages, channels, users, reactions and search results.
+ */
+export { renderChannel } from "./channel.js";
+export { formatSlackText, renderMessage, renderMessageList, renderThread, } from "./message.js";
+export { renderMessageReactions, renderReactedMessages, } from "./reactions.js";
+export { renderFileList } from "./search.js";
+export { renderUser } from "./user.js";

package/dist/slack/renderers/index.js

@@ -0,0 +1,9 @@
+/**
+ * Slack content renderers: markdown formatting for
+ * messages, channels, users, reactions and search results.
+ */
+export { renderChannel } from "./channel.js";
+export { formatSlackText, renderMessage, renderMessageList, renderThread, } from "./message.js";
+export { renderMessageReactions, renderReactedMessages, } from "./reactions.js";
+export { renderFileList } from "./search.js";
+export { renderUser } from "./user.js";

package/dist/slack/renderers/message.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Format Slack messages and threads as readable text.
+ *
+ * Converts Slack's mrkdwn format to markdown-like output.
+ * User IDs (<@U123>) are resolved from the local cache
+ * when possible.
+ */
+import type { SlackMessage } from "../types.js";
+/**
+ * Convert Slack mrkdwn to readable text.
+ *
+ * Handles user mentions, channel links, URL links, and
+ * basic formatting differences between Slack and markdown.
+ */
+export declare function formatSlackText(text: string): string;
+/** Format a single message as a readable block. */
+export declare function renderMessage(msg: SlackMessage): string;
+/** Format a list of messages (search results or channel history). */
+export declare function renderMessageList(messages: SlackMessage[], total?: number, query?: string): string;
+/** Format a thread as a readable conversation. */
+export declare function renderThread(messages: SlackMessage[]): string;

package/dist/slack/renderers/message.js

@@ -0,0 +1,214 @@
+/**
+ * Format Slack messages and threads as readable text.
+ *
+ * Converts Slack's mrkdwn format to markdown-like output.
+ * User IDs (<@U123>) are resolved from the local cache
+ * when possible.
+ */
+import { count } from "../../ui/count.js";
+import { cacheChannelName } from "../resolvers/conversation.js";
+import { cacheUser, displayNameForId } from "../resolvers/user.js";
+/**
+ * Convert Slack mrkdwn to readable text.
+ *
+ * Handles user mentions, channel links, URL links, and
+ * basic formatting differences between Slack and markdown.
+ */
+export function formatSlackText(text) {
+    return (text
+        // User mentions with label: <@U123|display.name> → @display.name
+        // Opportunistically cache the name → ID mapping for later unlabelled mentions.
+        .replace(/<@([UW][A-Z0-9]+)\|([^>]+)>/g, (_match, id, name) => {
+        cacheUser(name, id);
+        return `@${name}`;
+    })
+        // User mentions without label: <@U123> → @username or @U123
+        .replace(/<@([UW][A-Z0-9]+)>/g, (_match, id) => {
+        return `@${displayNameForId(id)}`;
+    })
+        // Broadcast mentions: <!here>, <!channel>, <!everyone> → @here etc.
+        .replace(/<!(here|channel|everyone)>/g, "@$1")
+        // Channel links with label: <#C123|channel-name> → #channel-name
+        // Opportunistically cache the name → ID mapping.
+        .replace(/<#([A-Z0-9]+)\|([^>]+)>/g, (_match, id, name) => {
+        cacheChannelName(name, id);
+        return `#${name}`;
+    })
+        // Channel links without label: <#C123> → #channel-name (via cache)
+        .replace(/<#([A-Z0-9]+)>/g, (_match, id) => {
+        return `#${displayNameForId(id)}`;
+    })
+        // URL links with label: <url|text> → [text](url)
+        .replace(/<(https?:\/\/[^|>]+)\|([^>]+)>/g, "[$2]($1)")
+        // URL links without label: <url> → url
+        .replace(/<(https?:\/\/[^>]+)>/g, "$1")
+        // Mailto links: <mailto:a@b.com|a@b.com> → a@b.com
+        .replace(/<mailto:([^|>]+)\|([^>]+)>/g, "$2")
+        .replace(/<mailto:([^>]+)>/g, "$1")
+        // Slack bold *text* → **text** (markdown bold)
+        .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, "**$1**"));
+}
+/**
+ * Render a SlackTable as a pipe-delimited markdown table.
+ *
+ * Pads cells to column widths for readability.
+ */
+function renderTable(table) {
+    // Calculate column widths.
+    const widths = table.columns.map((col, i) => Math.max(col.length, ...table.rows.map((row) => (row[i] ?? "").length)));
+    // Header row.
+    const header = table.columns
+        .map((col, i) => col.padEnd(widths[i]))
+        .join(" | ");
+    // Separator row.
+    const separator = widths.map((w) => "-".repeat(w)).join(" | ");
+    // Data rows.
+    const rows = table.rows.map((row) => row.map((cell, i) => (cell ?? "").padEnd(widths[i])).join(" | "));
+    return [
+        `| ${header} |`,
+        `| ${separator} |`,
+        ...rows.map((r) => `| ${r} |`),
+    ].join("\n");
+}
+/**
+ * Render a message's attachments, files and reactions as lines.
+ *
+ * Shared by renderMessage (no prefix) and renderThread
+ * (indented prefix). Each line is prefixed with the given
+ * string so thread rendering can maintain its visual tree.
+ */
+function renderMessageExtras(msg, prefix) {
+    const lines = [];
+    if (msg.attachments?.length) {
+        for (const att of msg.attachments) {
+            const title = att.title || att.fallback;
+            const url = att.fromUrl || att.imageUrl;
+            if (title && url) {
+                lines.push(`${prefix}📎 [${title}](${url})`);
+            }
+            else if (title) {
+                lines.push(`${prefix}📎 ${title}`);
+            }
+            else if (url) {
+                lines.push(`${prefix}📎 ${url}`);
+            }
+            if (att.text) {
+                for (const line of formatSlackText(att.text).split("\n")) {
+                    lines.push(`${prefix}${line}`);
+                }
+            }
+        }
+    }
+    if (msg.files?.length) {
+        for (const f of msg.files) {
+            const type = f.mimetype ? ` [${f.mimetype}]` : "";
+            if (f.url) {
+                lines.push(`${prefix}📄 [${f.name}](${f.url})${type}`);
+            }
+            else {
+                lines.push(`${prefix}📄 ${f.name}${type}`);
+            }
+        }
+    }
+    if (msg.reactions?.length) {
+        const rxns = msg.reactions.map((r) => `:${r.name}: ${r.count}`).join("  ");
+        lines.push(`${prefix}${rxns}`);
+    }
+    return lines;
+}
+/** Format a single message as a readable block. */
+export function renderMessage(msg) {
+    const parts = [];
+    const user = msg.user ? `@${displayNameForId(msg.user)}` : "unknown";
+    const ts = formatTimestamp(msg.ts);
+    const where = msg.conversation?.displayName
+        ? ` (${msg.conversation.displayName})`
+        : "";
+    const replyTag = msg.replyCount
+        ? ` [${msg.replyCount} ${msg.replyCount === 1 ? "reply" : "replies"}]`
+        : "";
+    parts.push(`**${user}** ${ts} (ts:${msg.ts})${where}${replyTag}`);
+    if (msg.text) {
+        parts.push(formatSlackText(msg.text));
+    }
+    if (msg.tables?.length) {
+        for (const table of msg.tables) {
+            parts.push(renderTable(table));
+        }
+    }
+    parts.push(...renderMessageExtras(msg, ""));
+    if (msg.permalink) {
+        parts.push(`[link](${msg.permalink})`);
+    }
+    return parts.join("\n");
+}
+/** Format a list of messages (search results or channel history). */
+export function renderMessageList(messages, total, query) {
+    if (messages.length === 0) {
+        return "No messages found.";
+    }
+    const lines = [];
+    if (query) {
+        lines.push(`Query: ${query}`);
+    }
+    if (total !== undefined) {
+        const truncated = total > messages.length;
+        const showing = truncated
+            ? `, showing ${messages.length} (limit reached, so pass a higher limit or 0 for all)`
+            : `, showing ${messages.length}`;
+        lines.push(`Found ${count(total, "message")}${showing}:\n`);
+    }
+    for (const msg of messages) {
+        lines.push(renderMessage(msg));
+        lines.push(""); // Blank line separator
+    }
+    return lines.join("\n").trimEnd();
+}
+/** Format a thread as a readable conversation. */
+export function renderThread(messages) {
+    if (messages.length === 0) {
+        return "Empty thread.";
+    }
+    const lines = [];
+    lines.push(`Thread with ${count(messages.length, "message")}:\n`);
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        const prefix = i === 0 ? "┌" : i === messages.length - 1 ? "└" : "├";
+        const user = msg.user ? `@${displayNameForId(msg.user)}` : "unknown";
+        const ts = formatTimestamp(msg.ts);
+        lines.push(`${prefix} **${user}** ${ts} (ts:${msg.ts})`);
+        const indent = i === messages.length - 1 ? "  " : "│ ";
+        if (msg.text) {
+            for (const line of formatSlackText(msg.text).split("\n")) {
+                lines.push(`${indent}${line}`);
+            }
+        }
+        if (msg.tables?.length) {
+            for (const table of msg.tables) {
+                for (const line of renderTable(table).split("\n")) {
+                    lines.push(`${indent}${line}`);
+                }
+            }
+        }
+        lines.push(...renderMessageExtras(msg, indent));
+        if (i < messages.length - 1)
+            lines.push("│");
+    }
+    return lines.join("\n");
+}
+/** Format a Slack timestamp as a human-readable date/time. */
+function formatTimestamp(ts) {
+    try {
+        const epochSeconds = Number.parseFloat(ts);
+        const date = new Date(epochSeconds * 1000);
+        return date.toLocaleString(undefined, {
+            month: "short",
+            day: "numeric",
+            hour: "numeric",
+            minute: "2-digit",
+        });
+    }
+    catch {
+        return ts;
+    }
+}

package/dist/slack/renderers/reactions.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Format reaction data as readable text.
+ */
+import type { MessageReactions, ReactedMessage } from "../api/reactions.js";
+/** Render reactions on a specific message. */
+export declare function renderMessageReactions(data: MessageReactions): string;
+/** Render a list of messages the user reacted to. */
+export declare function renderReactedMessages(messages: ReactedMessage[]): string;

package/dist/slack/renderers/reactions.js

@@ -0,0 +1,43 @@
+/**
+ * Format reaction data as readable text.
+ */
+import { count } from "../../ui/count.js";
+import { displayNameForId } from "../resolvers/user.js";
+import { formatSlackText } from "./message.js";
+/** Render reactions on a specific message. */
+export function renderMessageReactions(data) {
+    const lines = [];
+    if (data.text) {
+        const user = data.user ? `@${displayNameForId(data.user)}` : "unknown";
+        lines.push(`**${user}**: ${formatSlackText(data.text)}`);
+        lines.push("");
+    }
+    if (data.reactions.length === 0) {
+        lines.push("No reactions.");
+    }
+    else {
+        lines.push("Reactions:");
+        for (const r of data.reactions) {
+            lines.push(`  :${r.name}: × ${r.count}`);
+        }
+    }
+    return lines.join("\n");
+}
+/** Render a list of messages the user reacted to. */
+export function renderReactedMessages(messages) {
+    if (messages.length === 0) {
+        return "No reactions found.";
+    }
+    const lines = [];
+    lines.push(`${count(messages.length, "message")} with reactions:\n`);
+    for (const msg of messages) {
+        const user = msg.user ? `@${displayNameForId(msg.user)}` : "unknown";
+        const text = msg.text
+            ? formatSlackText(msg.text).slice(0, 80)
+            : "(no text)";
+        const rxns = msg.reactions.map((r) => `:${r.name}: ${r.count}`).join("  ");
+        lines.push(`- **${user}**: ${text}`);
+        lines.push(`  ${rxns}`);
+    }
+    return lines.join("\n");
+}

package/dist/slack/renderers/search.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Format search results as readable text.
+ */
+import type { SlackFileResult } from "../api/search.js";
+/** Render file search results. */
+export declare function renderFileList(files: SlackFileResult[], total: number, query?: string): string;