discoclaw 0.1.0

package/dist/discord/output-common.test.js

@@ -0,0 +1,198 @@
+import { describe, expect, it, vi } from 'vitest';
+import { buildAttachments, imageMediaTypeToExtension, editThenSendChunks, replyThenSendChunks, sendChunks, shouldSuppressFollowUp, buildUnavailableActionTypesNotice, appendUnavailableActionTypesNotice, } from './output-common.js';
+describe('imageMediaTypeToExtension', () => {
+    it('maps known types', () => {
+        expect(imageMediaTypeToExtension('image/png')).toBe('png');
+        expect(imageMediaTypeToExtension('image/jpeg')).toBe('jpeg');
+        expect(imageMediaTypeToExtension('image/webp')).toBe('webp');
+        expect(imageMediaTypeToExtension('image/gif')).toBe('gif');
+    });
+    it('defaults to png for unknown', () => {
+        expect(imageMediaTypeToExtension('image/bmp')).toBe('png');
+    });
+});
+describe('buildAttachments', () => {
+    it('creates correct filenames and buffers', () => {
+        const images = [
+            { base64: Buffer.from('png-data').toString('base64'), mediaType: 'image/png' },
+            { base64: Buffer.from('jpeg-data').toString('base64'), mediaType: 'image/jpeg' },
+        ];
+        const attachments = buildAttachments(images);
+        expect(attachments).toHaveLength(2);
+        expect(attachments[0].name).toBe('image-1.png');
+        expect(attachments[1].name).toBe('image-2.jpeg');
+    });
+    it('returns empty array for empty input', () => {
+        expect(buildAttachments([])).toHaveLength(0);
+    });
+});
+describe('editThenSendChunks with images', () => {
+    function mockReply() {
+        return { edit: vi.fn().mockResolvedValue(undefined) };
+    }
+    function mockChannel() {
+        return { send: vi.fn().mockResolvedValue(undefined) };
+    }
+    it('sends text-only with no images', async () => {
+        const reply = mockReply();
+        const channel = mockChannel();
+        await editThenSendChunks(reply, channel, 'hello');
+        expect(reply.edit).toHaveBeenCalledOnce();
+        expect(reply.edit.mock.calls[0][0].content).toBe('hello');
+        expect(reply.edit.mock.calls[0][0].files).toBeUndefined();
+    });
+    it('sends image-only when text is empty', async () => {
+        const reply = mockReply();
+        const channel = mockChannel();
+        const images = [
+            { base64: Buffer.from('test').toString('base64'), mediaType: 'image/png' },
+        ];
+        await editThenSendChunks(reply, channel, '', images);
+        expect(reply.edit).toHaveBeenCalledOnce();
+        expect(reply.edit.mock.calls[0][0].content).toBe('');
+        expect(reply.edit.mock.calls[0][0].files).toHaveLength(1);
+    });
+    it('attaches images to single text chunk in one edit', async () => {
+        const reply = mockReply();
+        const channel = mockChannel();
+        const images = [
+            { base64: Buffer.from('test').toString('base64'), mediaType: 'image/png' },
+        ];
+        await editThenSendChunks(reply, channel, 'Response text', images);
+        // Should only call edit once (no double-edit)
+        expect(reply.edit).toHaveBeenCalledOnce();
+        expect(reply.edit.mock.calls[0][0].content).toBe('Response text');
+        expect(reply.edit.mock.calls[0][0].files).toHaveLength(1);
+    });
+    it('attaches images to last chunk in multi-chunk text', async () => {
+        const reply = mockReply();
+        const channel = mockChannel();
+        const images = [
+            { base64: Buffer.from('img').toString('base64'), mediaType: 'image/png' },
+        ];
+        // Generate text long enough to split into multiple chunks (>2000 chars)
+        const longText = 'A'.repeat(2100);
+        await editThenSendChunks(reply, channel, longText, images);
+        // First chunk via edit (no files), remaining via channel.send
+        expect(reply.edit).toHaveBeenCalledOnce();
+        expect(reply.edit.mock.calls[0][0].files).toBeUndefined();
+        // Last send should have files
+        const sendCalls = channel.send.mock.calls;
+        expect(sendCalls.length).toBeGreaterThanOrEqual(1);
+        const lastSend = sendCalls[sendCalls.length - 1][0];
+        expect(lastSend.files).toHaveLength(1);
+    });
+    it('shows (no output) when empty text and no images', async () => {
+        const reply = mockReply();
+        const channel = mockChannel();
+        await editThenSendChunks(reply, channel, '');
+        expect(reply.edit).toHaveBeenCalledOnce();
+        expect(reply.edit.mock.calls[0][0].content).toBe('(no output)');
+    });
+});
+describe('replyThenSendChunks with images', () => {
+    function mockMessage() {
+        return {
+            reply: vi.fn().mockResolvedValue(undefined),
+            channel: { send: vi.fn().mockResolvedValue(undefined) },
+        };
+    }
+    it('sends image-only with empty text', async () => {
+        const message = mockMessage();
+        const images = [
+            { base64: Buffer.from('test').toString('base64'), mediaType: 'image/png' },
+        ];
+        await replyThenSendChunks(message, '', images);
+        expect(message.reply).toHaveBeenCalledOnce();
+        expect(message.reply.mock.calls[0][0].content).toBe('');
+        expect(message.reply.mock.calls[0][0].files).toHaveLength(1);
+    });
+    it('shows (no output) when no text and no images', async () => {
+        const message = mockMessage();
+        await replyThenSendChunks(message, '');
+        expect(message.reply).toHaveBeenCalledOnce();
+        expect(message.reply.mock.calls[0][0].content).toBe('(no output)');
+    });
+});
+describe('shouldSuppressFollowUp', () => {
+    it('suppresses when text is short and all counts are zero', () => {
+        expect(shouldSuppressFollowUp('hi', 0, 0, 0)).toBe(true);
+    });
+    it('suppresses when text is empty and all counts are zero', () => {
+        expect(shouldSuppressFollowUp('', 0, 0, 0)).toBe(true);
+    });
+    it('suppresses when whitespace-collapsed text is under 50 chars', () => {
+        const text = '   a   b   c   '; // collapses to "a b c" (5 chars)
+        expect(shouldSuppressFollowUp(text, 0, 0, 0)).toBe(true);
+    });
+    it('does not suppress when text is 50 chars or more', () => {
+        const text = 'A'.repeat(50);
+        expect(shouldSuppressFollowUp(text, 0, 0, 0)).toBe(false);
+    });
+    it('does not suppress when actionsCount > 0', () => {
+        expect(shouldSuppressFollowUp('hi', 1, 0, 0)).toBe(false);
+    });
+    it('does not suppress when imagesCount > 0', () => {
+        expect(shouldSuppressFollowUp('hi', 0, 1, 0)).toBe(false);
+    });
+    it('does not suppress when strippedUnrecognizedCount > 0, even with short text', () => {
+        expect(shouldSuppressFollowUp('', 0, 0, 1)).toBe(false);
+    });
+    it('does not suppress when strippedUnrecognizedCount > 0, even with zero actions and images', () => {
+        expect(shouldSuppressFollowUp('short', 0, 0, 3)).toBe(false);
+    });
+});
+describe('buildUnavailableActionTypesNotice', () => {
+    it('returns empty string when no types were stripped', () => {
+        expect(buildUnavailableActionTypesNotice([])).toBe('');
+    });
+    it('renders singular notice for one unavailable type', () => {
+        const out = buildUnavailableActionTypesNotice(['channelCreate']);
+        expect(out).toContain('Ignored unavailable action type:');
+        expect(out).toContain('`channelCreate`');
+    });
+    it('deduplicates and renders plural notice for multiple unavailable types', () => {
+        const out = buildUnavailableActionTypesNotice(['taskSync', 'taskSync', 'planRun']);
+        expect(out).toContain('Ignored unavailable action types:');
+        expect(out).toContain('`taskSync`');
+        expect(out).toContain('`planRun`');
+    });
+});
+describe('appendUnavailableActionTypesNotice', () => {
+    it('appends the notice under existing text', () => {
+        const out = appendUnavailableActionTypesNotice('hello', ['channelCreate']);
+        expect(out).toContain('hello');
+        expect(out).toContain('Ignored unavailable action type');
+    });
+    it('returns notice alone when base text is empty', () => {
+        const out = appendUnavailableActionTypesNotice('', ['channelCreate']);
+        expect(out.startsWith('Ignored unavailable action type')).toBe(true);
+    });
+    it('returns original text when no stripped types are provided', () => {
+        expect(appendUnavailableActionTypesNotice('hello', [])).toBe('hello');
+    });
+});
+describe('sendChunks with images', () => {
+    function mockChannel() {
+        return { send: vi.fn().mockResolvedValue(undefined) };
+    }
+    it('sends image-only with empty text', async () => {
+        const channel = mockChannel();
+        const images = [
+            { base64: Buffer.from('test').toString('base64'), mediaType: 'image/png' },
+        ];
+        await sendChunks(channel, '', images);
+        expect(channel.send).toHaveBeenCalledOnce();
+        expect(channel.send.mock.calls[0][0].content).toBe('');
+        expect(channel.send.mock.calls[0][0].files).toHaveLength(1);
+    });
+    it('attaches images to last text chunk', async () => {
+        const channel = mockChannel();
+        const images = [
+            { base64: Buffer.from('test').toString('base64'), mediaType: 'image/png' },
+        ];
+        await sendChunks(channel, 'Hello world', images);
+        expect(channel.send).toHaveBeenCalledOnce();
+        expect(channel.send.mock.calls[0][0].files).toHaveLength(1);
+    });
+});

package/dist/discord/output-utils.js

@@ -0,0 +1,156 @@
+export function splitDiscord(text, limit = 2000) {
+    // Minimal fence-safe markdown chunking.
+    const normalized = text.replace(/\r\n?/g, '\n');
+    if (normalized.length <= limit)
+        return [normalized];
+    const rawLines = normalized.split('\n');
+    const chunks = [];
+    let cur = '';
+    let inFence = false;
+    let fenceHeader = '```';
+    const effectiveCurLen = () => {
+        if (cur.length > 0)
+            return cur.length;
+        return inFence ? fenceHeader.length : 0;
+    };
+    const remainingRoom = () => {
+        const base = effectiveCurLen();
+        const sep = base > 0 ? 1 : 0;
+        return Math.max(0, limit - base - sep);
+    };
+    const ensureFenceOpen = () => {
+        if (cur)
+            return;
+        if (inFence)
+            cur = `${fenceHeader}`;
+    };
+    const flush = () => {
+        if (!cur)
+            return;
+        if (inFence && !cur.trimEnd().endsWith('```')) {
+            const close = '\n```';
+            if (cur.length + close.length <= limit) {
+                cur += close;
+            }
+        }
+        chunks.push(cur);
+        cur = '';
+    };
+    const appendLine = (line) => {
+        ensureFenceOpen();
+        const sep = cur.length > 0 ? '\n' : '';
+        cur += sep + line;
+    };
+    for (const line of rawLines) {
+        const curLen = effectiveCurLen();
+        const nextLen = (curLen ? curLen + 1 : 0) + line.length;
+        if (nextLen > limit && cur) {
+            flush();
+        }
+        if (line.length > remainingRoom()) {
+            let rest = line;
+            while (rest.length > 0) {
+                const room = Math.max(1, remainingRoom());
+                const take = rest.slice(0, room);
+                appendLine(take);
+                rest = rest.slice(room);
+                if (rest.length > 0) {
+                    flush();
+                }
+            }
+        }
+        else {
+            appendLine(line);
+        }
+        const trimmed = line.trimStart();
+        if (trimmed.startsWith('```')) {
+            if (!inFence) {
+                inFence = true;
+                fenceHeader = trimmed.trimEnd();
+            }
+            else {
+                inFence = false;
+                fenceHeader = '```';
+            }
+        }
+        if (inFence && cur.length >= limit - 8) {
+            flush();
+        }
+    }
+    flush();
+    return chunks.filter((c) => c.trim().length > 0);
+}
+export function truncateCodeBlocks(text, maxLines = 20) {
+    // Truncate fenced code blocks that exceed maxLines, keeping first/last lines.
+    return text.replace(/^([ \t]*```[^\n]*\n)([\s\S]*?)(^[ \t]*```[ \t]*$)/gm, (_match, open, body, close) => {
+        const lines = body.split('\n');
+        const trimmedLines = lines.length > 0 && lines[lines.length - 1] === '' ? lines.slice(0, -1) : lines;
+        if (trimmedLines.length <= maxLines)
+            return open + body + close;
+        const keepTop = Math.ceil(maxLines / 2);
+        const keepBottom = Math.floor(maxLines / 2);
+        const omitted = trimmedLines.length - keepTop - keepBottom;
+        const top = trimmedLines.slice(0, keepTop);
+        const bottom = trimmedLines.slice(trimmedLines.length - keepBottom);
+        return (open +
+            top.join('\n') + '\n' +
+            `... (${omitted} lines omitted)\n` +
+            bottom.join('\n') + '\n' +
+            close);
+    });
+}
+export function renderDiscordTail(text, maxLines = 8, maxWidth = 72) {
+    const normalized = String(text ?? '').replace(/\r\n?/g, '\n');
+    const lines = normalized.split('\n').filter((l) => l.length > 0);
+    const tail = lines.slice(-maxLines).map((l) => l.length > maxWidth ? l.slice(0, maxWidth - 1) + '\u2026' : l);
+    while (tail.length < maxLines)
+        tail.unshift('\u200b');
+    const safe = tail.join('\n').replace(/```/g, '``\\`');
+    return `\`\`\`text\n${safe}\n\`\`\``;
+}
+export function formatBoldLabel(label, maxWidth = 72) {
+    const singleLine = label.split('\n').find((l) => l.length > 0) ?? '';
+    const truncated = singleLine.length > maxWidth
+        ? singleLine.slice(0, maxWidth - 1) + '\u2026'
+        : singleLine;
+    const safe = truncated.replace(/([*_~|`\\[\]])/g, '\\$1');
+    return `**${safe}**`;
+}
+export function renderActivityTail(label, maxLines = 8, maxWidth = 72) {
+    const lines = [];
+    for (let i = 0; i < maxLines; i++)
+        lines.push('\u200b');
+    const safe = lines.join('\n').replace(/```/g, '``\\`');
+    return `${formatBoldLabel(label, maxWidth)}\n\`\`\`text\n${safe}\n\`\`\``;
+}
+export function thinkingLabel(tick) {
+    const dotCounts = [1, 2, 3, 0];
+    return 'Thinking' + '.'.repeat(dotCounts[tick % 4]);
+}
+export function formatElapsed(ms) {
+    const totalSeconds = Math.floor(ms / 1000);
+    if (totalSeconds < 60)
+        return `(${totalSeconds}s)`;
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return `(${minutes}m${seconds}s)`;
+}
+export function selectStreamingOutput(opts) {
+    const preview = opts.showPreview ?? true;
+    const prefix = opts.elapsedMs !== undefined ? formatElapsed(opts.elapsedMs) + ' ' : '';
+    // finalText always bypasses the gate — completion/error output renders immediately.
+    if (!preview && !opts.finalText) {
+        if (opts.activityLabel)
+            return formatBoldLabel(prefix + opts.activityLabel);
+        return formatBoldLabel(prefix + thinkingLabel(opts.statusTick));
+    }
+    if (opts.deltaText) {
+        const label = prefix + thinkingLabel(opts.statusTick);
+        return `**${label}**\n${renderDiscordTail(opts.deltaText)}`;
+    }
+    if (opts.activityLabel)
+        return renderActivityTail(prefix + opts.activityLabel);
+    if (opts.finalText)
+        return renderDiscordTail(opts.finalText);
+    return renderActivityTail(prefix + thinkingLabel(opts.statusTick));
+}

package/dist/discord/parse-identity-name.test.js

@@ -0,0 +1,129 @@
+import { describe, expect, it, vi } from 'vitest';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { parseIdentityName, resolveDisplayName } from '../identity.js';
+describe('parseIdentityName', () => {
+    it('parses "- **Name:** Weston" format', async () => {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'identity-'));
+        try {
+            await fs.writeFile(path.join(dir, 'IDENTITY.md'), '# Identity\n\n- **Name:** Weston\n- **Vibe:** chill', 'utf8');
+            const result = await parseIdentityName(dir);
+            expect(result).toBe('Weston');
+        }
+        finally {
+            await fs.rm(dir, { recursive: true });
+        }
+    });
+    it('parses "**Name**: Weston" format (no leading dash)', async () => {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'identity-'));
+        try {
+            await fs.writeFile(path.join(dir, 'IDENTITY.md'), '# Identity\n\n**Name**: Weston\n', 'utf8');
+            const result = await parseIdentityName(dir);
+            expect(result).toBe('Weston');
+        }
+        finally {
+            await fs.rm(dir, { recursive: true });
+        }
+    });
+    it('parses "Name: Weston" format (no bold)', async () => {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'identity-'));
+        try {
+            await fs.writeFile(path.join(dir, 'IDENTITY.md'), '# Identity\n\nName: Weston\n', 'utf8');
+            const result = await parseIdentityName(dir);
+            expect(result).toBe('Weston');
+        }
+        finally {
+            await fs.rm(dir, { recursive: true });
+        }
+    });
+    it('returns undefined for empty/missing name value', async () => {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'identity-'));
+        try {
+            await fs.writeFile(path.join(dir, 'IDENTITY.md'), '# Identity\n\nNo name here\n', 'utf8');
+            const result = await parseIdentityName(dir);
+            expect(result).toBeUndefined();
+        }
+        finally {
+            await fs.rm(dir, { recursive: true });
+        }
+    });
+    it('returns undefined for missing file (ENOENT)', async () => {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'identity-'));
+        try {
+            const result = await parseIdentityName(dir);
+            expect(result).toBeUndefined();
+        }
+        finally {
+            await fs.rm(dir, { recursive: true });
+        }
+    });
+    it('trims whitespace from the name', async () => {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'identity-'));
+        try {
+            await fs.writeFile(path.join(dir, 'IDENTITY.md'), '- **Name:**   Weston  \n', 'utf8');
+            const result = await parseIdentityName(dir);
+            expect(result).toBe('Weston');
+        }
+        finally {
+            await fs.rm(dir, { recursive: true });
+        }
+    });
+});
+describe('resolveDisplayName', () => {
+    it('uses configName when provided', async () => {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'identity-'));
+        try {
+            await fs.writeFile(path.join(dir, 'IDENTITY.md'), '- **Name:** Ignored\n', 'utf8');
+            const result = await resolveDisplayName({ configName: 'FromConfig', workspaceCwd: dir });
+            expect(result).toBe('FromConfig');
+        }
+        finally {
+            await fs.rm(dir, { recursive: true });
+        }
+    });
+    it('falls back to IDENTITY.md name when configName is undefined', async () => {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'identity-'));
+        try {
+            await fs.writeFile(path.join(dir, 'IDENTITY.md'), '- **Name:** Weston\n', 'utf8');
+            const result = await resolveDisplayName({ workspaceCwd: dir });
+            expect(result).toBe('Weston');
+        }
+        finally {
+            await fs.rm(dir, { recursive: true });
+        }
+    });
+    it('falls back to Discoclaw when no name source exists', async () => {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'identity-'));
+        try {
+            const result = await resolveDisplayName({ workspaceCwd: dir });
+            expect(result).toBe('Discoclaw');
+        }
+        finally {
+            await fs.rm(dir, { recursive: true });
+        }
+    });
+    it('truncates names exceeding 32 characters', async () => {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'identity-'));
+        const log = { warn: vi.fn() };
+        try {
+            const longName = 'A'.repeat(40);
+            const result = await resolveDisplayName({ configName: longName, workspaceCwd: dir, log });
+            expect(result).toBe('A'.repeat(32));
+            expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ original: longName, truncated: 'A'.repeat(32) }), expect.stringContaining('truncating'));
+        }
+        finally {
+            await fs.rm(dir, { recursive: true });
+        }
+    });
+    it('falls back to Discoclaw for whitespace-only configName', async () => {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'identity-'));
+        try {
+            const result = await resolveDisplayName({ configName: '   ', workspaceCwd: dir });
+            expect(result).toBe('Discoclaw');
+        }
+        finally {
+            await fs.rm(dir, { recursive: true });
+        }
+    });
+});