discoclaw 0.1.0

package/dist/discord/actions-guild.js

@@ -0,0 +1,301 @@
+import { GuildScheduledEventEntityType, GuildScheduledEventPrivacyLevel } from 'discord.js';
+import { resolveChannel, fmtTime } from './action-utils.js';
+const GUILD_TYPE_MAP = {
+    memberInfo: true, roleInfo: true, roleAdd: true, roleRemove: true,
+    searchMessages: true, eventList: true, eventCreate: true, eventEdit: true, eventDelete: true,
+};
+export const GUILD_ACTION_TYPES = new Set(Object.keys(GUILD_TYPE_MAP));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+// Discord epoch: 2015-01-01T00:00:00.000Z
+const DISCORD_EPOCH = 1420070400000n;
+/**
+ * Convert an ISO date string or raw snowflake ID to a Discord snowflake string.
+ * Returns null on invalid input.
+ */
+export function isoToSnowflake(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return null;
+    // Already a snowflake (numeric string, 17-20 digits)?
+    if (/^\d{17,20}$/.test(trimmed))
+        return trimmed;
+    // Try ISO date parse.
+    const ms = Date.parse(trimmed);
+    if (isNaN(ms))
+        return null;
+    if (BigInt(ms) < DISCORD_EPOCH)
+        return null;
+    const snowflake = (BigInt(ms) - DISCORD_EPOCH) << 22n;
+    return snowflake.toString();
+}
+function resolveRole(guild, ref) {
+    // Try by ID.
+    const byId = guild.roles.cache.get(ref);
+    if (byId)
+        return byId;
+    // Try by name (case-insensitive).
+    return guild.roles.cache.find((r) => r.name.toLowerCase() === ref.toLowerCase());
+}
+// ---------------------------------------------------------------------------
+// Executor
+// ---------------------------------------------------------------------------
+export async function executeGuildAction(action, ctx) {
+    const { guild } = ctx;
+    switch (action.type) {
+        case 'memberInfo': {
+            const member = await guild.members.fetch(action.userId).catch(() => null);
+            if (!member)
+                return { ok: false, error: `Member "${action.userId}" not found` };
+            const info = [
+                `Username: ${member.user.username}`,
+                `Display: ${member.displayName}`,
+                `ID: ${member.id}`,
+                `Joined: ${member.joinedAt ? fmtTime(member.joinedAt) : 'unknown'}`,
+                `Roles: ${member.roles.cache.filter((r) => r.name !== '@everyone').map((r) => r.name).join(', ') || '(none)'}`,
+            ];
+            if (member.user.bot)
+                info.push('Bot: yes');
+            return { ok: true, summary: info.join('\n') };
+        }
+        case 'roleInfo': {
+            const roles = [...guild.roles.cache.values()]
+                .filter((r) => r.name !== '@everyone')
+                .sort((a, b) => b.position - a.position);
+            if (roles.length === 0) {
+                return { ok: true, summary: 'No custom roles' };
+            }
+            const lines = roles.map((r) => {
+                const members = r.members?.size ?? '?';
+                return `${r.name} (id:${r.id}, ${members} members)`;
+            });
+            return { ok: true, summary: `Roles:\n${lines.join('\n')}` };
+        }
+        case 'roleAdd': {
+            const member = await guild.members.fetch(action.userId).catch(() => null);
+            if (!member)
+                return { ok: false, error: `Member "${action.userId}" not found` };
+            const role = resolveRole(guild, action.role);
+            if (!role)
+                return { ok: false, error: `Role "${action.role}" not found` };
+            await member.roles.add(role.id);
+            return { ok: true, summary: `Added role "${role.name}" to ${member.displayName}` };
+        }
+        case 'roleRemove': {
+            const member = await guild.members.fetch(action.userId).catch(() => null);
+            if (!member)
+                return { ok: false, error: `Member "${action.userId}" not found` };
+            const role = resolveRole(guild, action.role);
+            if (!role)
+                return { ok: false, error: `Role "${action.role}" not found` };
+            await member.roles.remove(role.id);
+            return { ok: true, summary: `Removed role "${role.name}" from ${member.displayName}` };
+        }
+        case 'searchMessages': {
+            const channel = action.channel
+                ? resolveChannel(guild, action.channel)
+                : guild.channels.cache.get(ctx.channelId);
+            if (!channel || !('messages' in channel)) {
+                return { ok: false, error: `Channel not found` };
+            }
+            const limit = Math.min(Math.max(1, action.limit ?? 25), 50);
+            const maxPages = Math.min(Math.max(1, action.maxPages ?? 5), 10);
+            const beforeSnowflake = action.before ? isoToSnowflake(action.before) : null;
+            const afterSnowflake = action.after ? isoToSnowflake(action.after) : null;
+            const query = action.query.toLowerCase();
+            const matches = [];
+            let cursor = beforeSnowflake ?? undefined;
+            let totalScanned = 0;
+            let hitAfterBound = false;
+            for (let page = 0; page < maxPages; page++) {
+                const fetchOpts = { limit: 100 };
+                if (cursor)
+                    fetchOpts.before = cursor;
+                const batch = await channel.messages.fetch(fetchOpts);
+                const msgs = [...batch.values()];
+                if (msgs.length === 0)
+                    break;
+                for (const m of msgs) {
+                    // If we've passed the after boundary, stop entirely.
+                    if (afterSnowflake && BigInt(m.id) <= BigInt(afterSnowflake)) {
+                        hitAfterBound = true;
+                        break;
+                    }
+                    totalScanned++;
+                    if (m.content?.toLowerCase().includes(query) && matches.length < limit) {
+                        matches.push(m);
+                    }
+                }
+                // Update cursor to oldest message in this batch.
+                cursor = msgs[msgs.length - 1].id;
+                if (hitAfterBound)
+                    break;
+                if (matches.length >= limit)
+                    break;
+                if (msgs.length < 100)
+                    break; // End of channel.
+            }
+            if (matches.length === 0) {
+                return { ok: true, summary: `No messages matching "${action.query}" in #${channel.name} (scanned ${totalScanned} messages)` };
+            }
+            const lines = matches.map((m) => {
+                const author = m.author?.username ?? 'Unknown';
+                const ts = m.createdAt ? fmtTime(m.createdAt) : '';
+                const text = (m.content || '').slice(0, 150);
+                return `[${ts}] [${author}] ${text} (id:${m.id})`;
+            });
+            return { ok: true, summary: `Search results for "${action.query}" in #${channel.name} (${matches.length} found, ${totalScanned} scanned):\n${lines.join('\n')}` };
+        }
+        case 'eventList': {
+            const events = await guild.scheduledEvents.fetch();
+            if (events.size === 0) {
+                return { ok: true, summary: 'No scheduled events' };
+            }
+            const lines = [...events.values()].map((e) => {
+                const start = e.scheduledStartAt ? fmtTime(e.scheduledStartAt) : 'TBD';
+                return `${e.name} (id:${e.id}) — ${start}${e.description ? ` — ${e.description.slice(0, 80)}` : ''}`;
+            });
+            return { ok: true, summary: `Scheduled events:\n${lines.join('\n')}` };
+        }
+        case 'eventCreate': {
+            const startTime = new Date(action.startTime);
+            if (isNaN(startTime.getTime())) {
+                return { ok: false, error: `Invalid startTime: "${action.startTime}"` };
+            }
+            const opts = {
+                name: action.name,
+                scheduledStartTime: startTime.toISOString(),
+                privacyLevel: GuildScheduledEventPrivacyLevel.GuildOnly,
+                description: action.description,
+            };
+            if (action.endTime) {
+                const endTime = new Date(action.endTime);
+                if (!isNaN(endTime.getTime())) {
+                    opts.scheduledEndTime = endTime.toISOString();
+                }
+            }
+            if (action.location) {
+                opts.entityType = GuildScheduledEventEntityType.External;
+                opts.entityMetadata = { location: action.location };
+                if (!opts.scheduledEndTime) {
+                    // External events require an end time. Default to +1 hour.
+                    opts.scheduledEndTime = new Date(startTime.getTime() + 3600_000).toISOString();
+                }
+            }
+            else if (action.channelId) {
+                opts.entityType = GuildScheduledEventEntityType.Voice;
+                opts.channel = action.channelId;
+            }
+            else {
+                opts.entityType = GuildScheduledEventEntityType.External;
+                opts.entityMetadata = { location: 'TBD' };
+                if (!opts.scheduledEndTime) {
+                    opts.scheduledEndTime = new Date(startTime.getTime() + 3600_000).toISOString();
+                }
+            }
+            const event = await guild.scheduledEvents.create(opts);
+            return { ok: true, summary: `Created event "${event.name}"` };
+        }
+        case 'eventEdit': {
+            const { eventId, name, startTime, endTime, description, location } = action;
+            if (!name && !startTime && !endTime && description === undefined && !location) {
+                return { ok: false, error: 'eventEdit requires at least one field to update' };
+            }
+            const edits = {};
+            if (name)
+                edits.name = name;
+            if (description !== undefined)
+                edits.description = description;
+            if (location)
+                edits.entityMetadata = { location };
+            if (startTime) {
+                const d = new Date(startTime);
+                if (isNaN(d.getTime()))
+                    return { ok: false, error: `Invalid startTime: "${startTime}"` };
+                edits.scheduledStartTime = d.toISOString();
+            }
+            if (endTime) {
+                const d = new Date(endTime);
+                if (isNaN(d.getTime()))
+                    return { ok: false, error: `Invalid endTime: "${endTime}"` };
+                edits.scheduledEndTime = d.toISOString();
+            }
+            const event = await guild.scheduledEvents.edit(eventId, edits);
+            return { ok: true, summary: `Edited event "${event.name}"` };
+        }
+        case 'eventDelete': {
+            const event = await guild.scheduledEvents.fetch(action.eventId).catch(() => null);
+            const name = event?.name ?? action.eventId;
+            await guild.scheduledEvents.delete(action.eventId);
+            return { ok: true, summary: `Deleted event "${name}"` };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Prompt section
+// ---------------------------------------------------------------------------
+export function guildActionsPromptSection() {
+    return `### Guild Info & Management
+
+**memberInfo** — Get info about a server member:
+\`\`\`
+<discord-action>{"type":"memberInfo","userId":"123456789"}</discord-action>
+\`\`\`
+
+**roleInfo** — List all roles in the server:
+\`\`\`
+<discord-action>{"type":"roleInfo"}</discord-action>
+\`\`\`
+
+**roleAdd** / **roleRemove** — Add or remove a role from a member:
+\`\`\`
+<discord-action>{"type":"roleAdd","userId":"123","role":"Moderator"}</discord-action>
+<discord-action>{"type":"roleRemove","userId":"123","role":"Moderator"}</discord-action>
+\`\`\`
+- \`role\`: Role name or ID.
+
+**searchMessages** — Search messages in a channel (paginated, client-side filter):
+\`\`\`
+<discord-action>{"type":"searchMessages","query":"keyword","channel":"#general","limit":10}</discord-action>
+\`\`\`
+- \`query\` (required): Text to search for (case-insensitive substring match).
+- \`channel\` (optional): Channel to search; defaults to current channel.
+- \`limit\` (optional): Max results (1–50, default 25).
+- \`before\` (optional): Message ID or ISO date — only search messages before this point.
+- \`after\` (optional): Message ID or ISO date — stop scanning at this point.
+- \`maxPages\` (optional): Pages of 100 messages to scan (1–10, default 5 = 500 messages).
+
+**eventList** — List scheduled events:
+\`\`\`
+<discord-action>{"type":"eventList"}</discord-action>
+\`\`\`
+
+**eventCreate** — Create a scheduled event:
+\`\`\`
+<discord-action>{"type":"eventCreate","name":"Team Meeting","startTime":"2025-02-01T15:00:00Z","description":"Weekly sync","location":"Zoom"}</discord-action>
+\`\`\`
+- \`name\` (required): Event name.
+- \`startTime\` (required): ISO 8601 datetime.
+- \`endTime\` (optional): ISO 8601 datetime.
+- \`description\` (optional): Event description.
+- \`channelId\` (optional): Voice channel ID for voice events.
+- \`location\` (optional): External location (creates an external event).
+
+**eventEdit** — Edit a scheduled event:
+\`\`\`
+<discord-action>{"type":"eventEdit","eventId":"123","name":"New Name","startTime":"2025-03-01T10:00:00Z"}</discord-action>
+\`\`\`
+- \`eventId\` (required): Event ID (from eventList).
+- \`name\` (optional): New event name.
+- \`startTime\` (optional): New ISO 8601 start time.
+- \`endTime\` (optional): New ISO 8601 end time.
+- \`description\` (optional): New description.
+- \`location\` (optional): New external location.
+At least one field besides eventId is required.
+
+**eventDelete** — Delete a scheduled event (destructive — confirm with user first):
+\`\`\`
+<discord-action>{"type":"eventDelete","eventId":"123"}</discord-action>
+\`\`\``;
+}

package/dist/discord/actions-guild.test.js

@@ -0,0 +1,386 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ChannelType } from 'discord.js';
+import { executeGuildAction, isoToSnowflake } from './actions-guild.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeMockMember(overrides = {}) {
+    const roles = new Map();
+    for (const r of (overrides.roles ?? [])) {
+        roles.set(r.id, r);
+    }
+    return {
+        id: overrides.id ?? 'user1',
+        displayName: overrides.displayName ?? 'TestUser',
+        user: {
+            username: overrides.username ?? 'testuser',
+            bot: overrides.bot ?? false,
+        },
+        joinedAt: overrides.joinedAt ?? new Date('2024-01-01T00:00:00Z'),
+        roles: {
+            cache: {
+                filter: (fn) => {
+                    const filtered = [...roles.values()].filter(fn);
+                    return { map: (mapFn) => filtered.map(mapFn) };
+                },
+                values: () => roles.values(),
+            },
+            add: vi.fn(async () => { }),
+            remove: vi.fn(async () => { }),
+        },
+        timeout: vi.fn(async () => { }),
+        kick: vi.fn(async () => { }),
+        ban: vi.fn(async () => { }),
+    };
+}
+function makeCtx(overrides = {}) {
+    const channels = new Map();
+    for (const ch of (overrides.channels ?? [])) {
+        channels.set(ch.id, ch);
+    }
+    const roles = new Map();
+    for (const r of (overrides.roles ?? [])) {
+        roles.set(r.id, r);
+    }
+    const members = new Map();
+    for (const m of (overrides.members ?? [])) {
+        members.set(m.id, m);
+    }
+    return {
+        guild: {
+            channels: {
+                cache: {
+                    get: (id) => channels.get(id),
+                    find: (fn) => {
+                        for (const ch of channels.values()) {
+                            if (fn(ch))
+                                return ch;
+                        }
+                        return undefined;
+                    },
+                    values: () => channels.values(),
+                },
+            },
+            members: {
+                fetch: vi.fn(async (id) => {
+                    const m = members.get(id);
+                    if (!m)
+                        throw new Error('not found');
+                    return m;
+                }),
+            },
+            roles: {
+                cache: {
+                    get: (id) => roles.get(id),
+                    find: (fn) => {
+                        for (const r of roles.values()) {
+                            if (fn(r))
+                                return r;
+                        }
+                        return undefined;
+                    },
+                    values: () => roles.values(),
+                },
+            },
+            scheduledEvents: {
+                fetch: vi.fn(async (idOrUndefined) => {
+                    if (typeof idOrUndefined === 'string') {
+                        const ev = overrides.events?.get(idOrUndefined);
+                        if (!ev)
+                            throw new Error('not found');
+                        return ev;
+                    }
+                    return overrides.events ?? new Map();
+                }),
+                create: vi.fn(async (opts) => ({ name: opts.name })),
+                edit: vi.fn(async (_id, opts) => ({ name: opts.name ?? 'Edited Event' })),
+                delete: vi.fn(async () => { }),
+            },
+        },
+        client: {},
+        channelId: 'ch1',
+        messageId: 'msg1',
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('memberInfo', () => {
+    it('returns member info', async () => {
+        const member = makeMockMember({
+            id: 'u1',
+            username: 'alice',
+            displayName: 'Alice',
+            roles: [{ id: 'r1', name: 'Admin' }],
+        });
+        const ctx = makeCtx({ members: [member] });
+        const result = await executeGuildAction({ type: 'memberInfo', userId: 'u1' }, ctx);
+        expect(result.ok).toBe(true);
+        const summary = result.summary;
+        expect(summary).toContain('Username: alice');
+        expect(summary).toContain('Display: Alice');
+        expect(summary).toContain('Admin');
+    });
+    it('fails when member not found', async () => {
+        const ctx = makeCtx({});
+        const result = await executeGuildAction({ type: 'memberInfo', userId: 'nonexistent' }, ctx);
+        expect(result).toEqual({ ok: false, error: 'Member "nonexistent" not found' });
+    });
+});
+describe('roleInfo', () => {
+    it('lists roles sorted by position', async () => {
+        const roles = [
+            { id: 'r1', name: 'Admin', position: 2, members: { size: 3 } },
+            { id: 'r2', name: 'Member', position: 1, members: { size: 10 } },
+        ];
+        const ctx = makeCtx({ roles });
+        const result = await executeGuildAction({ type: 'roleInfo' }, ctx);
+        expect(result.ok).toBe(true);
+        const summary = result.summary;
+        expect(summary).toContain('Admin');
+        expect(summary).toContain('Member');
+        // Admin should come first (higher position).
+        expect(summary.indexOf('Admin')).toBeLessThan(summary.indexOf('Member'));
+    });
+});
+describe('roleAdd / roleRemove', () => {
+    it('adds a role by name', async () => {
+        const member = makeMockMember({ id: 'u1', displayName: 'Alice' });
+        const role = { id: 'r1', name: 'Moderator', position: 1 };
+        const ctx = makeCtx({ members: [member], roles: [role] });
+        const result = await executeGuildAction({ type: 'roleAdd', userId: 'u1', role: 'Moderator' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Added role "Moderator" to Alice' });
+        expect(member.roles.add).toHaveBeenCalledWith('r1');
+    });
+    it('removes a role by name', async () => {
+        const member = makeMockMember({ id: 'u1', displayName: 'Alice' });
+        const role = { id: 'r1', name: 'Moderator', position: 1 };
+        const ctx = makeCtx({ members: [member], roles: [role] });
+        const result = await executeGuildAction({ type: 'roleRemove', userId: 'u1', role: 'Moderator' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Removed role "Moderator" from Alice' });
+        expect(member.roles.remove).toHaveBeenCalledWith('r1');
+    });
+    it('fails when role not found', async () => {
+        const member = makeMockMember({ id: 'u1' });
+        const ctx = makeCtx({ members: [member] });
+        const result = await executeGuildAction({ type: 'roleAdd', userId: 'u1', role: 'Nonexistent' }, ctx);
+        expect(result).toEqual({ ok: false, error: 'Role "Nonexistent" not found' });
+    });
+});
+describe('isoToSnowflake', () => {
+    it('passes through raw snowflake IDs', () => {
+        expect(isoToSnowflake('123456789012345678')).toBe('123456789012345678');
+    });
+    it('converts ISO date to snowflake', () => {
+        const result = isoToSnowflake('2025-01-01T00:00:00Z');
+        expect(result).not.toBeNull();
+        // Should be a large numeric string
+        expect(/^\d+$/.test(result)).toBe(true);
+    });
+    it('returns null for invalid input', () => {
+        expect(isoToSnowflake('not-a-date')).toBeNull();
+        expect(isoToSnowflake('')).toBeNull();
+    });
+    it('returns null for pre-epoch dates', () => {
+        expect(isoToSnowflake('2014-01-01')).toBeNull();
+        expect(isoToSnowflake('1970-01-01T00:00:00Z')).toBeNull();
+    });
+});
+describe('searchMessages', () => {
+    /** Helper: create a channel with a paginated messages.fetch mock. */
+    function makeChannel(pages) {
+        let callIdx = 0;
+        return {
+            id: 'ch1',
+            name: 'general',
+            type: ChannelType.GuildText,
+            messages: {
+                fetch: vi.fn(async () => {
+                    const page = pages[callIdx] ?? [];
+                    callIdx++;
+                    const map = new Map(page.map((m) => [m.id, m]));
+                    return map;
+                }),
+            },
+        };
+    }
+    it('finds matching messages across pages', async () => {
+        // Page 1: exactly 100 messages so pagination continues.
+        const page1 = Array.from({ length: 100 }, (_, i) => ({
+            id: String(10200 - i),
+            content: i === 5 ? 'Hello world' : 'noise',
+            author: { username: i === 5 ? 'bob' : 'filler' },
+        }));
+        const page2 = [
+            { id: '10050', content: 'Hello again', author: { username: 'carol' } },
+        ];
+        const ch = makeChannel([page1, page2]);
+        const ctx = makeCtx({ channels: [ch] });
+        const result = await executeGuildAction({ type: 'searchMessages', query: 'hello', channel: '#general' }, ctx);
+        expect(result.ok).toBe(true);
+        const summary = result.summary;
+        expect(summary).toContain('[bob]');
+        expect(summary).toContain('[carol]');
+        expect(summary).toContain('2 found');
+    });
+    it('stops scanning when channel is exhausted', async () => {
+        // Single partial page (< 100 messages).
+        const page1 = [
+            { id: '50', content: 'Match here', author: { username: 'alice' } },
+        ];
+        const ch = makeChannel([page1]);
+        const ctx = makeCtx({ channels: [ch] });
+        const result = await executeGuildAction({ type: 'searchMessages', query: 'match', channel: '#general' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ch.messages.fetch).toHaveBeenCalledTimes(1);
+    });
+    it('stops scanning when after boundary is hit mid-page', async () => {
+        // Use snowflake-length IDs. after boundary = message ID 15000000000000000150.
+        const page1 = [
+            { id: '15000000000000000200', content: 'Match A', author: { username: 'alice' } },
+            { id: '15000000000000000180', content: 'Match B', author: { username: 'bob' } },
+            { id: '15000000000000000160', content: 'Match C', author: { username: 'carol' } },
+            { id: '15000000000000000140', content: 'Match D past boundary', author: { username: 'dave' } },
+        ];
+        const ch = makeChannel([page1]);
+        const ctx = makeCtx({ channels: [ch] });
+        const result = await executeGuildAction({ type: 'searchMessages', query: 'match', channel: '#general', after: '15000000000000000150' }, ctx);
+        expect(result.ok).toBe(true);
+        const summary = result.summary;
+        // Only A, B, C should match (IDs > boundary).
+        expect(summary).toContain('3 found');
+        expect(summary).not.toContain('dave');
+    });
+    it('respects maxPages cap', async () => {
+        // 100 messages per page, maxPages = 1 → only 1 fetch call.
+        const fullPage = Array.from({ length: 100 }, (_, i) => ({
+            id: String(10000 - i),
+            content: i === 50 ? 'target' : 'noise',
+            author: { username: 'user' },
+        }));
+        const ch = makeChannel([fullPage, fullPage]);
+        const ctx = makeCtx({ channels: [ch] });
+        const result = await executeGuildAction({ type: 'searchMessages', query: 'target', channel: '#general', maxPages: 1 }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ch.messages.fetch).toHaveBeenCalledTimes(1);
+    });
+    it('returns no-match message with scan count', async () => {
+        const page1 = [
+            { id: '200', content: 'nothing relevant', author: { username: 'alice' } },
+        ];
+        const ch = makeChannel([page1]);
+        const ctx = makeCtx({ channels: [ch] });
+        const result = await executeGuildAction({ type: 'searchMessages', query: 'zzzzz', channel: '#general' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('No messages matching');
+        expect(result.summary).toContain('scanned 1');
+    });
+});
+describe('searchMessages — empty channel', () => {
+    function makeChannel(pages) {
+        let callIdx = 0;
+        return {
+            id: 'ch1',
+            name: 'general',
+            type: ChannelType.GuildText,
+            messages: {
+                fetch: vi.fn(async () => {
+                    const page = pages[callIdx] ?? [];
+                    callIdx++;
+                    return new Map(page.map((m) => [m.id, m]));
+                }),
+            },
+        };
+    }
+    it('returns no-match when channel has zero messages', async () => {
+        const ch = makeChannel([[]]);
+        const ctx = makeCtx({ channels: [ch] });
+        const result = await executeGuildAction({ type: 'searchMessages', query: 'anything', channel: '#general' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('No messages matching');
+        expect(ch.messages.fetch).toHaveBeenCalledTimes(1);
+    });
+});
+describe('eventList', () => {
+    it('lists events', async () => {
+        const events = new Map([
+            ['e1', { id: 'e1', name: 'Team Meeting', scheduledStartAt: new Date('2025-02-01T15:00:00Z'), description: 'Weekly sync' }],
+        ]);
+        const ctx = makeCtx({ events });
+        const result = await executeGuildAction({ type: 'eventList' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('Team Meeting (id:e1)');
+    });
+    it('shows empty message when no events', async () => {
+        const ctx = makeCtx({ events: new Map() });
+        const result = await executeGuildAction({ type: 'eventList' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'No scheduled events' });
+    });
+});
+describe('eventCreate', () => {
+    it('creates an external event with location', async () => {
+        const ctx = makeCtx({});
+        const result = await executeGuildAction({
+            type: 'eventCreate',
+            name: 'Offsite',
+            startTime: '2025-03-01T10:00:00Z',
+            location: 'Conference Room A',
+        }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Created event "Offsite"' });
+        expect(ctx.guild.scheduledEvents.create).toHaveBeenCalled();
+    });
+    it('fails with invalid startTime', async () => {
+        const ctx = makeCtx({});
+        const result = await executeGuildAction({ type: 'eventCreate', name: 'Bad', startTime: 'not-a-date' }, ctx);
+        expect(result).toEqual({ ok: false, error: 'Invalid startTime: "not-a-date"' });
+    });
+});
+describe('eventEdit', () => {
+    it('edits an event name', async () => {
+        const ctx = makeCtx({});
+        const result = await executeGuildAction({ type: 'eventEdit', eventId: 'e1', name: 'New Name' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Edited event "New Name"' });
+        expect(ctx.guild.scheduledEvents.edit).toHaveBeenCalledWith('e1', { name: 'New Name' });
+    });
+    it('edits multiple fields', async () => {
+        const ctx = makeCtx({});
+        const result = await executeGuildAction({ type: 'eventEdit', eventId: 'e1', name: 'Updated', description: 'New desc', startTime: '2025-06-01T10:00:00Z' }, ctx);
+        expect(result.ok).toBe(true);
+        const call = ctx.guild.scheduledEvents.edit.mock.calls[0];
+        expect(call[0]).toBe('e1');
+        expect(call[1]).toMatchObject({ name: 'Updated', description: 'New desc' });
+        expect(call[1].scheduledStartTime).toBeDefined();
+    });
+    it('fails when no fields provided', async () => {
+        const ctx = makeCtx({});
+        const result = await executeGuildAction({ type: 'eventEdit', eventId: 'e1' }, ctx);
+        expect(result).toEqual({ ok: false, error: 'eventEdit requires at least one field to update' });
+    });
+    it('fails with invalid startTime', async () => {
+        const ctx = makeCtx({});
+        const result = await executeGuildAction({ type: 'eventEdit', eventId: 'e1', startTime: 'nope' }, ctx);
+        expect(result).toEqual({ ok: false, error: 'Invalid startTime: "nope"' });
+    });
+    it('fails with invalid endTime', async () => {
+        const ctx = makeCtx({});
+        const result = await executeGuildAction({ type: 'eventEdit', eventId: 'e1', endTime: 'bad' }, ctx);
+        expect(result).toEqual({ ok: false, error: 'Invalid endTime: "bad"' });
+    });
+});
+describe('eventDelete', () => {
+    it('deletes an event and shows its name', async () => {
+        const events = new Map([
+            ['e1', { id: 'e1', name: 'Team Meeting' }],
+        ]);
+        const ctx = makeCtx({ events });
+        const result = await executeGuildAction({ type: 'eventDelete', eventId: 'e1' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Deleted event "Team Meeting"' });
+        expect(ctx.guild.scheduledEvents.delete).toHaveBeenCalledWith('e1');
+    });
+    it('falls back to eventId when event not found for name', async () => {
+        const ctx = makeCtx({});
+        const result = await executeGuildAction({ type: 'eventDelete', eventId: 'unknown-id' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Deleted event "unknown-id"' });
+        expect(ctx.guild.scheduledEvents.delete).toHaveBeenCalledWith('unknown-id');
+    });
+});