discoclaw 0.1.0

package/dist/discord/thread-context.js

@@ -0,0 +1,169 @@
+const DEFAULT_BUDGET_CHARS = 3000;
+const DEFAULT_RECENT_LIMIT = 10;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function hasMedia(m) {
+    const attSize = m.attachments && ('size' in m.attachments ? m.attachments.size : 0);
+    const embLen = m.embeds && ('length' in m.embeds ? m.embeds.length : 0);
+    return (attSize ?? 0) > 0 || (embLen ?? 0) > 0;
+}
+function formatMessageLine(m, botName, suffix) {
+    const content = String(m.content ?? '').trim();
+    const author = m.author.bot
+        ? botName
+        : (m.author.displayName || m.author.username);
+    const tag = suffix ? ` (${suffix})` : '';
+    if (content) {
+        return `[${author}${tag}]: ${content}`;
+    }
+    if (hasMedia(m)) {
+        return `[${author}${tag}]: [attachment/embed]`;
+    }
+    return null; // no content and no media — skip
+}
+// ---------------------------------------------------------------------------
+// Main function
+// ---------------------------------------------------------------------------
+/**
+ * Resolve thread context: the thread's starter message and recent posts.
+ *
+ * Returns null if the channel is not a thread.
+ * When only the thread name is available, returns it alone (still useful context).
+ * Errors are caught and logged — never throws.
+ */
+export async function resolveThreadContext(channel, currentMessageId, opts = {}) {
+    if (!channel.isThread())
+        return null;
+    const budget = opts.budgetChars ?? DEFAULT_BUDGET_CHARS;
+    const recentLimit = opts.recentMessageLimit ?? DEFAULT_RECENT_LIMIT;
+    const botName = opts.botDisplayName ?? 'Discoclaw';
+    const sections = [];
+    let remaining = budget;
+    const seenMessageIds = new Set();
+    // 1. Thread name
+    const threadName = channel.name?.trim();
+    if (threadName) {
+        sections.push(`Thread: "${threadName}"`);
+    }
+    // 2. Starter message (the original post that started the thread)
+    if (typeof channel.fetchStarterMessage === 'function') {
+        try {
+            const starter = await channel.fetchStarterMessage();
+            if (starter) {
+                const line = formatMessageLine(starter, botName, 'thread starter');
+                if (line) {
+                    if (line.length <= remaining) {
+                        sections.push(line);
+                        remaining -= line.length + 1;
+                        seenMessageIds.add(starter.id);
+                    }
+                    else if (remaining > 50) {
+                        sections.push(line.slice(0, remaining - 3) + '...');
+                        remaining = 0;
+                        seenMessageIds.add(starter.id);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            opts.log?.warn({ err }, 'thread-context: failed to fetch starter message');
+        }
+    }
+    // 3. Pinned thread messages (optional)
+    if (opts.includePinned && remaining > 50) {
+        const fetchPinned = channel.messages.fetchPinned;
+        if (typeof fetchPinned === 'function') {
+            try {
+                const pinned = await fetchPinned.call(channel.messages);
+                if (pinned && pinned.size > 0) {
+                    const sorted = Array.from(pinned.values())
+                        .sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+                    const pinnedLines = [];
+                    const maxPinnedLines = 3;
+                    for (const m of sorted) {
+                        if (pinnedLines.length >= maxPinnedLines)
+                            break;
+                        if (remaining <= 0)
+                            break;
+                        if (m.id && seenMessageIds.has(m.id))
+                            continue;
+                        const line = formatMessageLine(m, botName, 'pinned');
+                        if (!line)
+                            continue;
+                        if (line.length <= remaining) {
+                            pinnedLines.push(line);
+                            remaining -= line.length + 1;
+                            if (m.id)
+                                seenMessageIds.add(m.id);
+                        }
+                        else if (remaining > 50) {
+                            pinnedLines.push(line.slice(0, remaining - 3) + '...');
+                            remaining = 0;
+                            if (m.id)
+                                seenMessageIds.add(m.id);
+                            break;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    if (pinnedLines.length > 0) {
+                        sections.push('Pinned thread messages:');
+                        sections.push(...pinnedLines);
+                    }
+                }
+            }
+            catch (err) {
+                opts.log?.warn({ err }, 'thread-context: failed to fetch pinned messages');
+            }
+        }
+    }
+    // 4. Recent thread messages (before the current command message)
+    if (remaining > 50 && recentLimit > 0) {
+        try {
+            const messages = await channel.messages.fetch({
+                before: currentMessageId,
+                limit: recentLimit,
+            });
+            if (messages && messages.size > 0) {
+                // Sort by snowflake ID (ascending = chronological).
+                const sorted = Array.from(messages.values())
+                    .sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+                const lines = [];
+                for (const m of sorted) {
+                    // Deduplicate: skip the starter message if it appears in recent messages
+                    if (m.id && seenMessageIds.has(m.id))
+                        continue;
+                    const line = formatMessageLine(m, botName);
+                    if (!line)
+                        continue;
+                    if (line.length <= remaining) {
+                        lines.push(line);
+                        remaining -= line.length + 1;
+                        if (m.id)
+                            seenMessageIds.add(m.id);
+                    }
+                    else if (remaining > 50 && m.author.bot) {
+                        lines.push(line.slice(0, remaining - 3) + '...');
+                        remaining = 0;
+                        break;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (lines.length > 0) {
+                    sections.push('Recent thread messages:');
+                    sections.push(...lines);
+                }
+            }
+        }
+        catch (err) {
+            opts.log?.warn({ err }, 'thread-context: failed to fetch recent messages');
+        }
+    }
+    if (sections.length === 0)
+        return null;
+    return { section: sections.join('\n') };
+}

package/dist/discord/thread-context.test.js

@@ -0,0 +1,386 @@
+import { describe, expect, it, vi } from 'vitest';
+import { resolveThreadContext } from './thread-context.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function fakeMsg(id, content, username, bot = false, extra) {
+    return {
+        id,
+        author: { username, displayName: username, bot },
+        content,
+        ...extra,
+    };
+}
+function fakeThread(opts) {
+    return {
+        isThread: () => true,
+        name: opts.name,
+        fetchStarterMessage: opts.starterError
+            ? (async () => { throw new Error('forbidden'); })
+            : (async () => opts.starter ?? null),
+        messages: {
+            fetch: opts.fetchError
+                ? (async () => { throw new Error('forbidden'); })
+                : (async () => {
+                    const map = new Map();
+                    // Discord returns newest-first
+                    const msgs = [...(opts.messages ?? [])].reverse();
+                    for (const m of msgs)
+                        map.set(m.id, m);
+                    return map;
+                }),
+        },
+    };
+}
+function fakeNonThread() {
+    return {
+        isThread: () => false,
+        messages: {
+            fetch: async () => new Map(),
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('resolveThreadContext', () => {
+    it('returns null for non-thread channels', async () => {
+        const result = await resolveThreadContext(fakeNonThread(), '100');
+        expect(result).toBeNull();
+    });
+    it('returns thread name alone when no starter or messages are available', async () => {
+        const ch = fakeThread({ name: 'Login fails when session expires', messages: [] });
+        const result = await resolveThreadContext(ch, '100');
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('Thread: "Login fails when session expires"');
+    });
+    it('returns context with starter message and thread name', async () => {
+        const ch = fakeThread({
+            name: 'bug-discussion',
+            starter: {
+                id: '1',
+                author: { username: 'Alice', displayName: 'Alice', bot: false },
+                content: 'We need to fix the login flow',
+            },
+            messages: [],
+        });
+        const result = await resolveThreadContext(ch, '100');
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('Thread: "bug-discussion"');
+        expect(result.section).toContain('[Alice (thread starter)]: We need to fix the login flow');
+    });
+    it('returns context with recent messages in chronological order', async () => {
+        const ch = fakeThread({
+            name: 'feature-request',
+            starter: {
+                id: '1',
+                author: { username: 'Bob', displayName: 'Bob', bot: false },
+                content: 'Add dark mode',
+            },
+            messages: [
+                fakeMsg('2', 'I agree, dark mode would be great', 'Charlie'),
+                fakeMsg('3', 'What about the sidebar?', 'Bob'),
+            ],
+        });
+        const result = await resolveThreadContext(ch, '100');
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('[Bob (thread starter)]: Add dark mode');
+        expect(result.section).toContain('Recent thread messages:');
+        expect(result.section).toContain('[Charlie]: I agree, dark mode would be great');
+        expect(result.section).toContain('[Bob]: What about the sidebar?');
+        // Verify chronological order: Charlie (id 2) before Bob (id 3)
+        const charlieIdx = result.section.indexOf('[Charlie]');
+        const bobIdx = result.section.indexOf('[Bob]: What');
+        expect(charlieIdx).toBeLessThan(bobIdx);
+    });
+    it('includes pinned thread messages when includePinned is true', async () => {
+        const pinned = fakeMsg('pinned-1', 'Important pinned note', 'PinnedUser');
+        const ch = fakeThread({
+            name: 'pinned-thread',
+            starter: {
+                id: '1',
+                author: { username: 'Bob', displayName: 'Bob', bot: false },
+                content: 'Starter content',
+            },
+            messages: [
+                fakeMsg('2', 'First reply', 'Alice'),
+            ],
+        });
+        ch.messages.fetchPinned = async () => {
+            const map = new Map();
+            map.set(pinned.id, pinned);
+            return map;
+        };
+        const result = await resolveThreadContext(ch, 'current', { includePinned: true });
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('Pinned thread messages:');
+        expect(result.section).toContain('[PinnedUser (pinned)]: Important pinned note');
+    });
+    it('deduplicates starter message from recent messages', async () => {
+        const starter = {
+            id: '1',
+            author: { username: 'Alice', displayName: 'Alice', bot: false },
+            content: 'The original post',
+        };
+        const ch = fakeThread({
+            name: 'dedup-test',
+            starter,
+            // Simulate Discord returning the starter in recent messages too
+            messages: [
+                { ...starter },
+                fakeMsg('2', 'A reply', 'Bob'),
+            ],
+        });
+        const result = await resolveThreadContext(ch, '100');
+        expect(result).not.toBeNull();
+        // Starter should appear once as thread starter, not again in recent
+        const matches = result.section.match(/The original post/g);
+        expect(matches).toHaveLength(1);
+        expect(result.section).toContain('[Alice (thread starter)]: The original post');
+        expect(result.section).toContain('[Bob]: A reply');
+    });
+    it('uses bot display name for bot-authored messages', async () => {
+        const ch = fakeThread({
+            name: 'bot-thread',
+            starter: {
+                id: '1',
+                author: { username: 'bot', displayName: 'bot', bot: true },
+                content: 'Automated report',
+            },
+            messages: [
+                fakeMsg('2', 'Here are the results', 'bot', true),
+            ],
+        });
+        const result = await resolveThreadContext(ch, '100', { botDisplayName: 'TestBot' });
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('[TestBot (thread starter)]: Automated report');
+        expect(result.section).toContain('[TestBot]: Here are the results');
+    });
+    it('respects budget — truncates starter when content exceeds limit', async () => {
+        const longContent = 'A'.repeat(500);
+        const ch = fakeThread({
+            name: 'test-thread',
+            starter: {
+                id: '1',
+                author: { username: 'Alice', displayName: 'Alice', bot: false },
+                content: longContent,
+            },
+            messages: [],
+        });
+        const result = await resolveThreadContext(ch, '100', { budgetChars: 100 });
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('...');
+    });
+    it('drops recent messages when budget is exhausted', async () => {
+        const ch = fakeThread({
+            name: 'budget-test',
+            starter: {
+                id: '1',
+                author: { username: 'Alice', displayName: 'Alice', bot: false },
+                content: 'A'.repeat(200),
+            },
+            messages: [
+                fakeMsg('2', 'B'.repeat(200), 'Bob'),
+                fakeMsg('3', 'should not appear', 'Charlie'),
+            ],
+        });
+        // Budget just enough for thread name + starter + maybe one message
+        const result = await resolveThreadContext(ch, '100', { budgetChars: 300 });
+        expect(result).not.toBeNull();
+        expect(result.section).not.toContain('should not appear');
+    });
+    it('handles starter message fetch failure gracefully', async () => {
+        const log = { warn: vi.fn(), info: vi.fn(), error: vi.fn(), debug: vi.fn() };
+        const ch = fakeThread({
+            name: 'broken-thread',
+            starterError: true,
+            messages: [
+                fakeMsg('2', 'still here', 'Dave'),
+            ],
+        });
+        const result = await resolveThreadContext(ch, '100', { log });
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('[Dave]: still here');
+        expect(log.warn).toHaveBeenCalled();
+    });
+    it('handles starter message returning null gracefully', async () => {
+        const ch = fakeThread({
+            name: 'null-starter-thread',
+            starter: null,
+            messages: [
+                fakeMsg('2', 'discussion continues', 'Eve'),
+            ],
+        });
+        const result = await resolveThreadContext(ch, '100');
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('[Eve]: discussion continues');
+        expect(result.section).not.toContain('thread starter');
+    });
+    it('handles message fetch failure gracefully', async () => {
+        const log = { warn: vi.fn(), info: vi.fn(), error: vi.fn(), debug: vi.fn() };
+        const ch = fakeThread({
+            name: 'broken-thread',
+            starter: {
+                id: '1',
+                author: { username: 'Alice', displayName: 'Alice', bot: false },
+                content: 'The original post',
+            },
+            fetchError: true,
+        });
+        const result = await resolveThreadContext(ch, '100', { log });
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('[Alice (thread starter)]: The original post');
+        expect(log.warn).toHaveBeenCalled();
+    });
+    it('returns thread name when both fetches fail', async () => {
+        const log = { warn: vi.fn(), info: vi.fn(), error: vi.fn(), debug: vi.fn() };
+        const ch = fakeThread({
+            name: 'totally-broken',
+            starterError: true,
+            fetchError: true,
+        });
+        const result = await resolveThreadContext(ch, '100', { log });
+        expect(result).not.toBeNull();
+        expect(result.section).toBe('Thread: "totally-broken"');
+        expect(log.warn).toHaveBeenCalledTimes(2);
+    });
+    it('returns null when thread has no name, no starter, and no messages', async () => {
+        const ch = fakeThread({ messages: [] });
+        const result = await resolveThreadContext(ch, '100');
+        expect(result).toBeNull();
+    });
+    it('skips empty content messages without media', async () => {
+        const ch = fakeThread({
+            name: 'test',
+            starter: {
+                id: '1',
+                author: { username: 'Alice', displayName: 'Alice', bot: false },
+                content: '',
+            },
+            messages: [
+                fakeMsg('2', '', 'Bob'),
+                fakeMsg('3', 'actual content', 'Charlie'),
+            ],
+        });
+        const result = await resolveThreadContext(ch, '100');
+        expect(result).not.toBeNull();
+        expect(result.section).not.toContain('[Bob]');
+        expect(result.section).toContain('[Charlie]: actual content');
+    });
+    it('renders empty-content messages with attachments as [attachment/embed]', async () => {
+        const ch = fakeThread({
+            name: 'media-test',
+            starter: {
+                id: '1',
+                author: { username: 'Alice', displayName: 'Alice', bot: false },
+                content: '',
+                attachments: { size: 1 },
+            },
+            messages: [],
+        });
+        const result = await resolveThreadContext(ch, '100');
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('[Alice (thread starter)]: [attachment/embed]');
+    });
+    it('renders empty-content messages with embeds as [attachment/embed]', async () => {
+        const ch = fakeThread({
+            name: 'embed-test',
+            messages: [
+                fakeMsg('2', '', 'Bob', false, { attachments: { size: 0 }, embeds: [{}] }),
+            ],
+        });
+        const result = await resolveThreadContext(ch, '100');
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('[Bob]: [attachment/embed]');
+    });
+    it('handles channel without fetchStarterMessage method', async () => {
+        const ch = {
+            isThread: () => true,
+            name: 'no-starter-method',
+            messages: {
+                fetch: async () => {
+                    const map = new Map();
+                    map.set('2', fakeMsg('2', 'hello', 'User'));
+                    return map;
+                },
+            },
+        };
+        const result = await resolveThreadContext(ch, '100');
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('[User]: hello');
+    });
+    it('truncates bot messages in recent thread posts to fit budget', async () => {
+        const longBotResponse = 'B'.repeat(300);
+        const ch = fakeThread({
+            name: 'test',
+            starter: {
+                id: '1',
+                author: { username: 'Alice', displayName: 'Alice', bot: false },
+                content: 'Start',
+            },
+            messages: [
+                fakeMsg('2', longBotResponse, 'Discoclaw', true),
+            ],
+        });
+        const result = await resolveThreadContext(ch, '100', { budgetChars: 200 });
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('...');
+        expect(result.section.length).toBeLessThanOrEqual(250);
+    });
+    it('respects recentMessageLimit option', async () => {
+        const ch = fakeThread({
+            name: 'busy-thread',
+            starter: {
+                id: '1',
+                author: { username: 'Alice', displayName: 'Alice', bot: false },
+                content: 'Start here',
+            },
+            messages: [
+                fakeMsg('2', 'msg one', 'Bob'),
+                fakeMsg('3', 'msg two', 'Charlie'),
+                fakeMsg('4', 'msg three', 'Dave'),
+            ],
+        });
+        const result = await resolveThreadContext(ch, '100', { recentMessageLimit: 2 });
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('Recent thread messages:');
+    });
+    it('defaults botDisplayName to Discoclaw', async () => {
+        const ch = fakeThread({
+            name: 'test',
+            starter: {
+                id: '1',
+                author: { username: 'bot', displayName: 'bot', bot: true },
+                content: 'bot starter',
+            },
+            messages: [],
+        });
+        const result = await resolveThreadContext(ch, '100');
+        expect(result).not.toBeNull();
+        expect(result.section).toContain('[Discoclaw (thread starter)]');
+    });
+    it('sorts messages by snowflake ID for correct chronological order', async () => {
+        // Provide messages in non-chronological order in the Map
+        const ch = {
+            isThread: () => true,
+            name: 'sort-test',
+            messages: {
+                fetch: async () => {
+                    const map = new Map();
+                    // Insert out of order
+                    map.set('300', fakeMsg('300', 'third', 'Charlie'));
+                    map.set('100', fakeMsg('100', 'first', 'Alice'));
+                    map.set('200', fakeMsg('200', 'second', 'Bob'));
+                    return map;
+                },
+            },
+        };
+        const result = await resolveThreadContext(ch, '999');
+        expect(result).not.toBeNull();
+        const aliceIdx = result.section.indexOf('first');
+        const bobIdx = result.section.indexOf('second');
+        const charlieIdx = result.section.indexOf('third');
+        expect(aliceIdx).toBeLessThan(bobIdx);
+        expect(bobIdx).toBeLessThan(charlieIdx);
+    });
+});

package/dist/discord/tool-aware-queue.js

@@ -0,0 +1,116 @@
+import { toolActivityLabel } from '../runtime/tool-labels.js';
+export class ToolAwareQueue {
+    state = 'idle';
+    buffer = '';
+    flushTimer = null;
+    disposed = false;
+    emit;
+    flushDelayMs;
+    postToolDelayMs;
+    constructor(emit, opts) {
+        this.emit = emit;
+        this.flushDelayMs = opts?.flushDelayMs ?? 2000;
+        this.postToolDelayMs = opts?.postToolDelayMs ?? 500;
+    }
+    handleEvent(evt) {
+        if (this.disposed)
+            return;
+        switch (evt.type) {
+            case 'text_delta':
+                this.onTextDelta(evt.text);
+                break;
+            case 'text_final':
+                this.onTextFinal(evt.text);
+                break;
+            case 'tool_start':
+                this.onToolStart(evt.name, evt.input);
+                break;
+            case 'tool_end':
+                this.onToolEnd();
+                break;
+            case 'error':
+            case 'done':
+                this.cancelTimer();
+                break;
+        }
+    }
+    dispose() {
+        this.disposed = true;
+        this.cancelTimer();
+    }
+    onTextDelta(text) {
+        switch (this.state) {
+            case 'idle':
+                this.state = 'buffering_text';
+                this.buffer = text;
+                this.startFlushTimer(this.flushDelayMs);
+                break;
+            case 'buffering_text':
+                this.buffer += text;
+                break;
+            case 'tool_active':
+                // Buffer text during tool execution; discard on next tool or flush after tool ends.
+                this.buffer += text;
+                break;
+            case 'streaming_final':
+                this.emit({ type: 'stream_text', text });
+                break;
+        }
+    }
+    onTextFinal(text) {
+        this.cancelTimer();
+        this.state = 'streaming_final';
+        this.emit({ type: 'set_final', text });
+    }
+    onToolStart(name, input) {
+        this.cancelTimer();
+        const label = toolActivityLabel(name, input);
+        switch (this.state) {
+            case 'idle':
+            case 'buffering_text':
+                // Discard buffered narration text.
+                this.buffer = '';
+                this.state = 'tool_active';
+                this.emit({ type: 'show_activity', label });
+                break;
+            case 'tool_active':
+                // New tool replaces the current activity label.
+                this.emit({ type: 'show_activity', label });
+                break;
+            case 'streaming_final':
+                // Rare: tool starts after we began streaming. Switch to tool_active.
+                this.state = 'tool_active';
+                this.emit({ type: 'show_activity', label });
+                break;
+        }
+    }
+    onToolEnd() {
+        if (this.state !== 'tool_active')
+            return;
+        this.state = 'buffering_text';
+        this.buffer = '';
+        this.startFlushTimer(this.postToolDelayMs);
+    }
+    startFlushTimer(delayMs) {
+        this.cancelTimer();
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            this.flush();
+        }, delayMs);
+    }
+    flush() {
+        if (this.disposed || this.state !== 'buffering_text')
+            return;
+        this.state = 'streaming_final';
+        if (this.buffer) {
+            this.emit({ type: 'stream_text', text: this.buffer });
+            this.buffer = '';
+        }
+    }
+    cancelTimer() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+}