discoclaw 0.1.0

package/dist/beads/find-bead-by-thread.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { TaskStore } from '../tasks/store.js';
+import { findBeadByThreadId } from './bead-thread-cache.js';
+function makeStore(externalRefs) {
+    const store = new TaskStore({ prefix: 'ws' });
+    for (const externalRef of externalRefs) {
+        const b = store.create({ title: 'Test' });
+        store.update(b.id, { externalRef });
+    }
+    return store;
+}
+describe('findBeadByThreadId', () => {
+    it('returns bead when external_ref matches as discord:<threadId>', () => {
+        const store = makeStore([
+            'discord:111222333444555666',
+            'discord:999888777666555444',
+        ]);
+        const result = findBeadByThreadId('111222333444555666', store);
+        expect(result?.id).toBe('ws-001');
+    });
+    it('returns bead when external_ref is raw numeric ID', () => {
+        const store = makeStore(['111222333444555666']);
+        const result = findBeadByThreadId('111222333444555666', store);
+        expect(result?.id).toBe('ws-001');
+    });
+    it('returns null when no match', () => {
+        const store = makeStore(['discord:999888777666555444']);
+        const result = findBeadByThreadId('111222333444555666', store);
+        expect(result).toBeNull();
+    });
+    it('returns null when store is empty', () => {
+        const store = new TaskStore();
+        const result = findBeadByThreadId('111222333444555666', store);
+        expect(result).toBeNull();
+    });
+});

package/dist/beads/forum-guard.js

@@ -0,0 +1,2 @@
+import { initTasksForumGuard, } from '../tasks/forum-guard.js';
+export const initBeadsForumGuard = initTasksForumGuard;

package/dist/beads/forum-guard.test.js

@@ -0,0 +1,204 @@
+import { describe, expect, it, vi } from 'vitest';
+import { TaskStore } from '../tasks/store.js';
+import { initBeadsForumGuard } from './forum-guard.js';
+import { initTasksForumGuard } from '../tasks/forum-guard.js';
+vi.mock('../tasks/thread-cache.js', () => ({
+    findTaskByThreadId: vi.fn(),
+}));
+vi.mock('../tasks/discord-sync.js', () => ({
+    buildAppliedTagsWithStatus: vi.fn(() => ['tag-closed']),
+    buildThreadName: vi.fn(() => '✅ [001] My Bead'),
+}));
+import { findTaskByThreadId } from '../tasks/thread-cache.js';
+function makeClient(botUserId = 'bot-user-1') {
+    const listeners = {};
+    return {
+        on: vi.fn((event, cb) => {
+            (listeners[event] ??= []).push(cb);
+        }),
+        user: { id: botUserId },
+        _listeners: listeners,
+    };
+}
+function makeThread(overrides) {
+    return {
+        id: 'thread-1',
+        name: 'Bead 1',
+        parentId: 'beads-forum-1',
+        ownerId: 'bot-user-1',
+        appliedTags: [],
+        send: vi.fn().mockResolvedValue(undefined),
+        setArchived: vi.fn().mockResolvedValue(undefined),
+        setName: vi.fn().mockResolvedValue(undefined),
+        edit: vi.fn().mockResolvedValue(undefined),
+        client: { user: { id: 'bot-user-1' } },
+        ...overrides,
+    };
+}
+const MOCK_BEAD = { id: 'ws-001', title: 'My Bead', status: 'closed' };
+describe('initBeadsForumGuard', () => {
+    it('keeps compatibility export aligned to canonical task guard', () => {
+        expect(initBeadsForumGuard).toBe(initTasksForumGuard);
+    });
+    function setup(botUserId = 'bot-user-1') {
+        const client = makeClient(botUserId);
+        const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+        initBeadsForumGuard({ client: client, forumId: 'beads-forum-1', log });
+        const listeners = client._listeners['threadCreate'] ?? [];
+        expect(listeners.length).toBeGreaterThan(0);
+        return { listener: listeners[0], log };
+    }
+    it('rejects manually-created threads with guidance and archives', async () => {
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'some-user' });
+        await listener(thread);
+        expect(thread.send).toHaveBeenCalledWith(expect.stringContaining('bd create'));
+        expect(thread.setArchived).toHaveBeenCalledWith(true);
+    });
+    it('allows bot-created threads through without sending or archiving', async () => {
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'bot-user-1' });
+        await listener(thread);
+        expect(thread.send).not.toHaveBeenCalled();
+        expect(thread.setArchived).not.toHaveBeenCalled();
+    });
+    it('ignores threads from other forums', async () => {
+        const { listener } = setup();
+        const thread = makeThread({ parentId: 'other-forum', ownerId: 'some-user' });
+        await listener(thread);
+        expect(thread.send).not.toHaveBeenCalled();
+        expect(thread.setArchived).not.toHaveBeenCalled();
+    });
+    it('handles send failure without preventing archive attempt', async () => {
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'some-user' });
+        thread.send.mockRejectedValue(new Error('Missing Access'));
+        await listener(thread);
+        expect(thread.setArchived).toHaveBeenCalledWith(true);
+    });
+});
+describe('initBeadsForumGuard threadUpdate', () => {
+    function setup(botUserId = 'bot-user-1') {
+        const client = makeClient(botUserId);
+        const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+        initBeadsForumGuard({ client: client, forumId: 'beads-forum-1', log });
+        const listeners = client._listeners['threadUpdate'] ?? [];
+        expect(listeners.length).toBeGreaterThan(0);
+        return { listener: listeners[0], log };
+    }
+    it('rejects unarchived manual thread', async () => {
+        const { listener } = setup();
+        const oldThread = makeThread({ ownerId: 'some-user', archived: true });
+        const newThread = makeThread({ ownerId: 'some-user', archived: false });
+        await listener(oldThread, newThread);
+        expect(newThread.send).toHaveBeenCalledWith(expect.stringContaining('bd create'));
+        expect(newThread.setArchived).toHaveBeenCalledWith(true);
+    });
+    it('allows bot-owned unarchived thread through', async () => {
+        const { listener } = setup();
+        const oldThread = makeThread({ archived: true });
+        const newThread = makeThread({ archived: false });
+        await listener(oldThread, newThread);
+        expect(newThread.send).not.toHaveBeenCalled();
+        expect(newThread.setArchived).not.toHaveBeenCalled();
+    });
+    it('ignores archive transitions (thread being archived)', async () => {
+        const { listener } = setup();
+        const oldThread = makeThread({ ownerId: 'some-user', archived: false });
+        const newThread = makeThread({ ownerId: 'some-user', archived: true });
+        await listener(oldThread, newThread);
+        expect(newThread.send).not.toHaveBeenCalled();
+    });
+});
+describe('initBeadsForumGuard bead-aware re-archive (threadCreate)', () => {
+    function setup() {
+        const client = makeClient();
+        const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+        initBeadsForumGuard({
+            client: client,
+            forumId: 'beads-forum-1',
+            log,
+            store: new TaskStore(),
+            tagMap: { closed: 'tag-closed' },
+        });
+        const listener = (client._listeners['threadCreate'] ?? [])[0];
+        return { listener, log };
+    }
+    it('re-archives known bead thread without sending rejection message', async () => {
+        vi.mocked(findTaskByThreadId).mockReturnValue(MOCK_BEAD);
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'some-user' });
+        await listener(thread);
+        expect(thread.send).not.toHaveBeenCalled();
+        expect(thread.edit).toHaveBeenCalled();
+        expect(thread.setName).toHaveBeenCalledWith('✅ [001] My Bead');
+        expect(thread.setArchived).toHaveBeenCalledWith(true);
+    });
+    it('falls through to rejection when bead lookup returns null', async () => {
+        vi.mocked(findTaskByThreadId).mockReturnValue(null);
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'some-user' });
+        await listener(thread);
+        expect(thread.send).toHaveBeenCalledWith(expect.stringContaining('bd create'));
+        expect(thread.setArchived).toHaveBeenCalledWith(true);
+    });
+    it('falls through to rejection when bead lookup throws', async () => {
+        vi.mocked(findTaskByThreadId).mockImplementation(() => { throw new Error('fs error'); });
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'some-user' });
+        await listener(thread);
+        expect(thread.send).toHaveBeenCalledWith(expect.stringContaining('bd create'));
+        expect(thread.setArchived).toHaveBeenCalledWith(true);
+    });
+    it('still archives even when edit throws', async () => {
+        vi.mocked(findTaskByThreadId).mockReturnValue(MOCK_BEAD);
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'some-user' });
+        thread.edit.mockRejectedValue(new Error('edit failed'));
+        await listener(thread);
+        expect(thread.setArchived).toHaveBeenCalledWith(true);
+    });
+    it('still archives even when setName throws', async () => {
+        vi.mocked(findTaskByThreadId).mockReturnValue(MOCK_BEAD);
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'some-user' });
+        thread.setName.mockRejectedValue(new Error('setName failed'));
+        await listener(thread);
+        expect(thread.setArchived).toHaveBeenCalledWith(true);
+    });
+});
+describe('initBeadsForumGuard bead-aware re-archive (threadUpdate)', () => {
+    function setup() {
+        const client = makeClient();
+        const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+        initBeadsForumGuard({
+            client: client,
+            forumId: 'beads-forum-1',
+            log,
+            store: new TaskStore(),
+            tagMap: { closed: 'tag-closed' },
+        });
+        const listener = (client._listeners['threadUpdate'] ?? [])[0];
+        return { listener, log };
+    }
+    it('re-archives known bead thread on unarchive without rejection message', async () => {
+        vi.mocked(findTaskByThreadId).mockReturnValue(MOCK_BEAD);
+        const { listener } = setup();
+        const oldThread = makeThread({ ownerId: 'some-user', archived: true });
+        const newThread = makeThread({ ownerId: 'some-user', archived: false });
+        await listener(oldThread, newThread);
+        expect(newThread.send).not.toHaveBeenCalled();
+        expect(newThread.edit).toHaveBeenCalled();
+        expect(newThread.setName).toHaveBeenCalledWith('✅ [001] My Bead');
+        expect(newThread.setArchived).toHaveBeenCalledWith(true);
+    });
+    it('falls through to rejection when bead not found on threadUpdate', async () => {
+        vi.mocked(findTaskByThreadId).mockReturnValue(null);
+        const { listener } = setup();
+        const oldThread = makeThread({ ownerId: 'some-user', archived: true });
+        const newThread = makeThread({ ownerId: 'some-user', archived: false });
+        await listener(oldThread, newThread);
+        expect(newThread.send).toHaveBeenCalledWith(expect.stringContaining('bd create'));
+        expect(newThread.setArchived).toHaveBeenCalledWith(true);
+    });
+});

package/dist/beads/initialize.js

@@ -0,0 +1,3 @@
+import { initializeTasksContext, wireTaskSync, } from '../tasks/initialize.js';
+export const initializeBeadsContext = initializeTasksContext;
+export const wireBeadsSync = wireTaskSync;

package/dist/beads/initialize.test.js

@@ -0,0 +1,304 @@
+import { describe, expect, it, vi } from 'vitest';
+// ---------------------------------------------------------------------------
+// Module mocks
+// ---------------------------------------------------------------------------
+vi.mock('../tasks/discord-sync.js', () => ({
+    loadTagMap: vi.fn().mockResolvedValue({ bug: '111', feature: '222' }),
+}));
+vi.mock('../tasks/forum-guard.js', () => ({
+    initTasksForumGuard: vi.fn(),
+}));
+vi.mock('../tasks/sync-coordinator.js', () => ({
+    TaskSyncCoordinator: vi.fn().mockImplementation(() => ({
+        sync: vi.fn().mockResolvedValue(undefined),
+    })),
+}));
+import { initTasksForumGuard } from '../tasks/forum-guard.js';
+import { TaskSyncCoordinator } from '../tasks/sync-coordinator.js';
+import { initializeBeadsContext, wireBeadsSync } from './initialize.js';
+import { initializeTasksContext, wireTaskSync } from '../tasks/initialize.js';
+import { TaskStore } from '../tasks/store.js';
+import { withDirectTaskLifecycle } from '../tasks/task-lifecycle.js';
+function fakeLog() {
+    return {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    };
+}
+function baseOpts(overrides = {}) {
+    return {
+        enabled: true,
+        tasksCwd: '/tmp/beads',
+        tasksForum: 'forum-123',
+        tasksTagMapPath: '/tmp/tag-map.json',
+        tasksSidebar: false,
+        tasksAutoTag: true,
+        tasksAutoTagModel: 'haiku',
+        runtime: {},
+        log: fakeLog(),
+        ...overrides,
+    };
+}
+describe('initializeBeadsContext', () => {
+    it('keeps compatibility exports aligned to canonical task initialize helpers', () => {
+        expect(initializeBeadsContext).toBe(initializeTasksContext);
+        expect(wireBeadsSync).toBe(wireTaskSync);
+    });
+    it('returns undefined with no warnings when disabled', async () => {
+        const log = fakeLog();
+        const result = await initializeBeadsContext(baseOpts({ enabled: false, log }));
+        expect(result.taskCtx).toBeUndefined();
+        expect(log.warn).not.toHaveBeenCalled();
+    });
+    it('returns undefined and warns when no forum resolved', async () => {
+        const log = fakeLog();
+        const result = await initializeBeadsContext(baseOpts({
+            tasksForum: '',
+            systemTasksForumId: undefined,
+            log,
+        }));
+        expect(result.taskCtx).toBeUndefined();
+        expect(log.warn).toHaveBeenCalledWith(expect.stringContaining('no forum resolved'));
+    });
+    it('returns TaskContext when all prerequisites met', async () => {
+        const log = fakeLog();
+        const result = await initializeBeadsContext(baseOpts({ log }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.forumId).toBe('forum-123');
+        expect(result.taskCtx.autoTag).toBe(true);
+    });
+    it('resolves forum from systemTasksForumId when tasksForum is empty', async () => {
+        const result = await initializeBeadsContext(baseOpts({
+            tasksForum: '',
+            systemTasksForumId: 'system-forum-456',
+        }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.forumId).toBe('system-forum-456');
+    });
+    it('sets sidebarMentionUserId when sidebar enabled with mention user', async () => {
+        const log = fakeLog();
+        const result = await initializeBeadsContext(baseOpts({
+            tasksSidebar: true,
+            tasksMentionUser: 'user-789',
+            log,
+        }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.sidebarMentionUserId).toBe('user-789');
+        expect(log.warn).not.toHaveBeenCalled();
+    });
+    it('warns when sidebar enabled but mention user not set', async () => {
+        const log = fakeLog();
+        const result = await initializeBeadsContext(baseOpts({
+            tasksSidebar: true,
+            tasksMentionUser: undefined,
+            log,
+        }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.sidebarMentionUserId).toBeUndefined();
+        expect(log.warn).toHaveBeenCalledWith(expect.stringContaining('sidebar mentions will be inactive'));
+    });
+    it('does not set sidebarMentionUserId when sidebar disabled', async () => {
+        const log = fakeLog();
+        const result = await initializeBeadsContext(baseOpts({
+            tasksSidebar: false,
+            tasksMentionUser: 'user-789',
+            log,
+        }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.sidebarMentionUserId).toBeUndefined();
+        expect(log.warn).not.toHaveBeenCalled();
+    });
+    it('propagates tagMapPath to TaskContext', async () => {
+        const result = await initializeBeadsContext(baseOpts({
+            tasksTagMapPath: '/my/custom/tag-map.json',
+        }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.tagMapPath).toBe('/my/custom/tag-map.json');
+    });
+    it('uses provided store instead of creating a new one', async () => {
+        const store = new TaskStore();
+        const result = await initializeBeadsContext(baseOpts({ store }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.store).toBe(store);
+    });
+});
+describe('wireBeadsSync', () => {
+    it('wires forum guard, coordinator, and store event listeners', async () => {
+        const log = fakeLog();
+        const store = new TaskStore();
+        const taskCtx = {
+            tasksCwd: '/tmp/beads',
+            forumId: 'forum-123',
+            tagMap: { bug: '111' },
+            store,
+            log,
+        };
+        const client = {};
+        const guild = {};
+        const result = await wireBeadsSync({
+            taskCtx,
+            client,
+            guild,
+            guildId: 'guild-1',
+            tasksCwd: '/tmp/beads',
+            sidebarMentionUserId: 'user-1',
+            log,
+        });
+        expect(initTasksForumGuard).toHaveBeenCalledWith({
+            client,
+            forumId: 'forum-123',
+            log,
+            store,
+            tagMap: { bug: '111' },
+        });
+        expect(TaskSyncCoordinator).toHaveBeenCalledWith(expect.objectContaining({
+            client,
+            guild,
+            forumId: 'forum-123',
+            mentionUserId: 'user-1',
+        }));
+        // The coordinator's sync() should have been called (fire-and-forget startup sync).
+        const coordinatorInstance = vi.mocked(TaskSyncCoordinator).mock.results[0]?.value;
+        expect(coordinatorInstance.sync).toHaveBeenCalled();
+        expect(taskCtx.syncCoordinator).toBeDefined();
+        expect(result).toHaveProperty('stop');
+        expect(log.info).toHaveBeenCalledWith(expect.objectContaining({ tasksCwd: '/tmp/beads' }), 'tasks:store-event watcher started');
+    });
+    it('store events trigger coordinator sync', async () => {
+        const log = fakeLog();
+        const store = new TaskStore({ prefix: 'test' });
+        const taskCtx = {
+            tasksCwd: '/tmp/beads',
+            forumId: 'forum-123',
+            tagMap: { bug: '111' },
+            tagMapPath: '/tmp/tag-map.json',
+            store,
+            log,
+        };
+        vi.mocked(TaskSyncCoordinator).mockClear();
+        await wireBeadsSync({
+            taskCtx,
+            client: {},
+            guild: {},
+            guildId: 'guild-1',
+            tasksCwd: '/tmp/beads',
+            log,
+        });
+        const coordinatorInstance = vi.mocked(TaskSyncCoordinator).mock.results[0]?.value;
+        // 'created' is intentionally NOT wired — beadCreate handles thread creation directly.
+        const callsBeforeCreate = coordinatorInstance.sync.mock.calls.length;
+        const bead = store.create({ title: 'Test task' });
+        expect(coordinatorInstance.sync.mock.calls.length).toBe(callsBeforeCreate);
+        // 'updated' IS wired — should trigger sync.
+        const callsBeforeUpdate = coordinatorInstance.sync.mock.calls.length;
+        store.update(bead.id, { title: 'Updated task' });
+        expect(coordinatorInstance.sync.mock.calls.length).toBeGreaterThan(callsBeforeUpdate);
+    });
+    it('does not trigger coordinator sync while direct task lifecycle ownership is active', async () => {
+        const log = fakeLog();
+        const store = new TaskStore({ prefix: 'test' });
+        const taskCtx = {
+            tasksCwd: '/tmp/beads',
+            forumId: 'forum-123',
+            tagMap: { bug: '111' },
+            tagMapPath: '/tmp/tag-map.json',
+            store,
+            log,
+        };
+        vi.mocked(TaskSyncCoordinator).mockClear();
+        await wireBeadsSync({
+            taskCtx,
+            client: {},
+            guild: {},
+            guildId: 'guild-1',
+            tasksCwd: '/tmp/beads',
+            log,
+        });
+        const coordinatorInstance = vi.mocked(TaskSyncCoordinator).mock.results[0]?.value;
+        const task = store.create({ title: 'Owned lifecycle task' });
+        const callsBeforeUpdate = coordinatorInstance.sync.mock.calls.length;
+        await withDirectTaskLifecycle(task.id, async () => {
+            store.update(task.id, { title: 'Updated while owned' });
+        });
+        expect(coordinatorInstance.sync.mock.calls.length).toBe(callsBeforeUpdate);
+    });
+    it('stop() removes store event listeners', async () => {
+        const log = fakeLog();
+        const store = new TaskStore({ prefix: 'test' });
+        const taskCtx = {
+            tasksCwd: '/tmp/beads',
+            forumId: 'forum-123',
+            tagMap: { bug: '111' },
+            tagMapPath: '/tmp/tag-map.json',
+            store,
+            log,
+        };
+        vi.mocked(TaskSyncCoordinator).mockClear();
+        const result = await wireBeadsSync({
+            taskCtx,
+            client: {},
+            guild: {},
+            guildId: 'guild-1',
+            tasksCwd: '/tmp/beads',
+            log,
+        });
+        result.stop();
+        const coordinatorInstance = vi.mocked(TaskSyncCoordinator).mock.results[0]?.value;
+        const callsAfterStop = coordinatorInstance.sync.mock.calls.length;
+        // After stop(), store mutations should NOT trigger additional syncs
+        const bead = store.create({ title: 'Another task' });
+        store.update(bead.id, { title: 'Modified' });
+        expect(coordinatorInstance.sync.mock.calls.length).toBe(callsAfterStop);
+    });
+    it('skips forum guard when skipForumGuard is true', async () => {
+        const log = fakeLog();
+        const store = new TaskStore();
+        const taskCtx = {
+            tasksCwd: '/tmp/beads',
+            forumId: 'forum-123',
+            tagMap: { bug: '111' },
+            tagMapPath: '/tmp/tag-map.json',
+            store,
+            log,
+        };
+        vi.mocked(initTasksForumGuard).mockClear();
+        await wireBeadsSync({
+            taskCtx,
+            client: {},
+            guild: {},
+            guildId: 'guild-1',
+            tasksCwd: '/tmp/beads',
+            log,
+            skipForumGuard: true,
+        });
+        expect(initTasksForumGuard).not.toHaveBeenCalled();
+        // Coordinator should still be wired
+        expect(TaskSyncCoordinator).toHaveBeenCalled();
+    });
+    it('propagates tagMapPath to CoordinatorOptions', async () => {
+        const log = fakeLog();
+        const tagMap = { bug: '111' };
+        const store = new TaskStore();
+        const taskCtx = {
+            tasksCwd: '/tmp/beads',
+            forumId: 'forum-123',
+            tagMap,
+            tagMapPath: '/config/tag-map.json',
+            store,
+            log,
+        };
+        await wireBeadsSync({
+            taskCtx,
+            client: {},
+            guild: {},
+            guildId: 'guild-1',
+            tasksCwd: '/tmp/beads',
+            log,
+        });
+        expect(TaskSyncCoordinator).toHaveBeenCalledWith(expect.objectContaining({
+            tagMapPath: '/config/tag-map.json',
+            tagMap,
+        }));
+    });
+});

package/dist/beads/types.js

@@ -0,0 +1,10 @@
+// ---------------------------------------------------------------------------
+// Re-export shim — canonical types live in src/tasks/types.ts.
+// All Bead* names are aliased from their Task* counterparts so existing
+// consumers compile unchanged.
+// ---------------------------------------------------------------------------
+export { TASK_STATUSES, isTaskStatus } from '../tasks/types.js';
+export { TASK_STATUSES as BEAD_STATUSES, isTaskStatus as isBeadStatus } from '../tasks/types.js';
+import { STATUS_EMOJI as _STATUS_EMOJI } from '../tasks/types.js';
+/** Status → emoji prefix for thread names. Widened to Record<string, string> for consumers that index with a plain string. */
+export const STATUS_EMOJI = _STATUS_EMOJI;