discoclaw 0.1.0

package/dist/tasks/task-sync-reconcile.js

@@ -0,0 +1,144 @@
+import { planTaskReconcileFromThreadSources, } from './task-sync-pipeline.js';
+import { closeTaskThread, isTaskThreadAlreadyClosed } from './thread-ops.js';
+import { extractShortIdFromThreadName, getThreadIdFromTask, shortTaskId, } from './thread-helpers.js';
+function sleep(ms) {
+    const n = ms ?? 0;
+    if (n <= 0)
+        return Promise.resolve();
+    return new Promise((r) => setTimeout(r, n));
+}
+async function applyReconcileOrphanThread(ctx, operation, state) {
+    state.orphanThreadsFound++;
+    ctx.log?.info({ threadId: operation.thread.id, threadName: operation.thread.name, shortId: operation.shortId }, 'task-sync:phase5 orphan thread detected');
+}
+async function applyReconcileCollision(ctx, operation) {
+    ctx.log?.info({ threadId: operation.thread.id, shortId: operation.shortId, count: operation.collisionCount }, 'task-sync:phase5 short-id collision, skipping');
+}
+async function applyReconcileSkipMismatch(ctx, operation) {
+    ctx.log?.info({ taskId: operation.task?.id, threadId: operation.thread.id, existingThreadId: operation.existingThreadId }, 'task-sync:phase5 external_ref points to different thread, skipping');
+}
+async function applyReconcileArchiveActiveClosed(ctx, operation, state) {
+    const task = operation.task;
+    if (!task)
+        return;
+    if (ctx.hasInFlightForChannel(operation.thread.id)) {
+        ctx.counters.closesDeferred++;
+        ctx.log?.info({ taskId: task.id, threadId: operation.thread.id }, 'task-sync:phase5 close deferred (in-flight reply active)');
+        return;
+    }
+    if (!operation.existingThreadId) {
+        try {
+            ctx.taskService.update(task.id, { externalRef: `discord:${operation.thread.id}` });
+            ctx.log?.info({ taskId: task.id, threadId: operation.thread.id }, 'task-sync:phase5 external_ref backfilled');
+        }
+        catch (err) {
+            ctx.log?.warn({ err, taskId: task.id, threadId: operation.thread.id }, 'task-sync:phase5 external_ref backfill failed');
+            ctx.counters.warnings++;
+        }
+    }
+    try {
+        await closeTaskThread(ctx.client, operation.thread.id, task, ctx.tagMap, ctx.log);
+        state.threadsReconciled++;
+        ctx.log?.info({ taskId: task.id, threadId: operation.thread.id }, 'task-sync:phase5 reconciled (archived)');
+    }
+    catch (err) {
+        ctx.log?.warn({ err, taskId: task.id, threadId: operation.thread.id }, 'task-sync:phase5 archive failed');
+        ctx.counters.warnings++;
+    }
+}
+async function applyReconcileArchivedClosed(ctx, operation, state) {
+    const task = operation.task;
+    if (!task)
+        return;
+    try {
+        const alreadyClosed = await isTaskThreadAlreadyClosed(ctx.client, operation.thread.id, task, ctx.tagMap);
+        if (!alreadyClosed) {
+            if (ctx.hasInFlightForChannel(operation.thread.id)) {
+                ctx.counters.closesDeferred++;
+                ctx.log?.info({ taskId: task.id, threadId: operation.thread.id }, 'task-sync:phase5 close deferred (in-flight reply active)');
+            }
+            else {
+                ctx.log?.info({ taskId: task.id, threadId: operation.thread.id }, 'task-sync:phase5 archived thread is stale, unarchiving to reconcile');
+                await closeTaskThread(ctx.client, operation.thread.id, task, ctx.tagMap, ctx.log);
+                state.threadsReconciled++;
+                ctx.log?.info({ taskId: task.id, threadId: operation.thread.id }, 'task-sync:phase5 reconciled (re-archived)');
+            }
+        }
+    }
+    catch (err) {
+        ctx.log?.warn({ err, taskId: task.id, threadId: operation.thread.id }, 'task-sync:phase5 archived reconcile failed');
+        ctx.counters.warnings++;
+    }
+}
+const RECONCILE_EXECUTORS = {
+    orphan: applyReconcileOrphanThread,
+    collision: applyReconcileCollision,
+    skip_external_ref_mismatch: applyReconcileSkipMismatch,
+    archive_active_closed: applyReconcileArchiveActiveClosed,
+    reconcile_archived_closed: applyReconcileArchivedClosed,
+};
+async function fetchPhase5ThreadSources(ctx) {
+    let activeThreads;
+    try {
+        const fetchedActive = await ctx.forum.threads.fetchActive();
+        activeThreads = fetchedActive.threads;
+    }
+    catch (err) {
+        ctx.log?.warn({ err }, 'task-sync:phase5 failed to fetch active threads');
+        ctx.counters.warnings++;
+        return null;
+    }
+    let archivedThreads = new Map();
+    try {
+        const fetchedArchived = await ctx.forum.threads.fetchArchived();
+        archivedThreads = new Map(fetchedArchived.threads);
+    }
+    catch (err) {
+        ctx.log?.warn({ err }, 'task-sync:phase5 failed to fetch archived threads');
+        ctx.counters.warnings++;
+    }
+    return { activeThreads, archivedThreads };
+}
+async function planPhase5ReconcileOperations(ctx, allTasks) {
+    const threadSources = await fetchPhase5ThreadSources(ctx);
+    if (!threadSources)
+        return null;
+    return planTaskReconcileFromThreadSources({
+        tasks: allTasks,
+        archivedThreads: threadSources.archivedThreads.values(),
+        activeThreads: threadSources.activeThreads.values(),
+        shortIdOfTaskId: shortTaskId,
+        shortIdFromThreadName: extractShortIdFromThreadName,
+        threadIdFromTask: getThreadIdFromTask,
+    });
+}
+async function applyPhase5ReconcileOperations(ctx, operations, state) {
+    for (const operation of operations) {
+        await RECONCILE_EXECUTORS[operation.action](ctx, operation, state);
+        await sleep(ctx.throttleMs);
+    }
+}
+async function applyPhase5ReconcileThreads(ctx, allTasks) {
+    const reconcileState = {
+        threadsReconciled: 0,
+        orphanThreadsFound: 0,
+    };
+    const plannedReconcileOps = await planPhase5ReconcileOperations(ctx, allTasks);
+    if (!plannedReconcileOps) {
+        return {
+            threadsReconciled: reconcileState.threadsReconciled,
+            orphanThreadsFound: reconcileState.orphanThreadsFound,
+        };
+    }
+    await applyPhase5ReconcileOperations(ctx, plannedReconcileOps, reconcileState);
+    return {
+        threadsReconciled: reconcileState.threadsReconciled,
+        orphanThreadsFound: reconcileState.orphanThreadsFound,
+    };
+}
+export async function runTaskSyncReconcilePhase(ctx, allTasks, opts) {
+    if (opts?.skipPhase5) {
+        return { threadsReconciled: 0, orphanThreadsFound: 0 };
+    }
+    return applyPhase5ReconcileThreads(ctx, allTasks);
+}

package/dist/tasks/task-sync.js

@@ -0,0 +1,56 @@
+import { TaskSyncCoordinator } from './sync-coordinator.js';
+import { TASK_SYNC_TRIGGER_EVENTS } from './sync-contract.js';
+import { isDirectTaskLifecycleActive } from './task-lifecycle.js';
+export async function ensureTaskSyncCoordinator(taskCtx, runCtx) {
+    if (taskCtx.syncCoordinator)
+        return taskCtx.syncCoordinator;
+    const syncCoordinator = new TaskSyncCoordinator({
+        client: runCtx.client,
+        guild: runCtx.guild,
+        forumId: taskCtx.forumId,
+        tagMap: taskCtx.tagMap,
+        tagMapPath: taskCtx.tagMapPath,
+        store: taskCtx.store,
+        taskService: taskCtx.taskService,
+        log: taskCtx.log,
+        mentionUserId: taskCtx.sidebarMentionUserId,
+        forumCountSync: taskCtx.forumCountSync,
+        hasInFlightForChannel: taskCtx.hasInFlightForChannel,
+        metrics: taskCtx.metrics,
+        ...(taskCtx.syncRunOptions ?? {}),
+        enableFailureRetry: taskCtx.syncFailureRetryEnabled,
+        failureRetryDelayMs: taskCtx.syncFailureRetryDelayMs,
+        deferredRetryDelayMs: taskCtx.syncDeferredRetryDelayMs,
+    });
+    taskCtx.syncCoordinator = syncCoordinator;
+    return syncCoordinator;
+}
+export async function runTaskSync(taskCtx, runCtx, statusPoster) {
+    const syncCoordinator = await ensureTaskSyncCoordinator(taskCtx, runCtx);
+    return syncCoordinator.sync(statusPoster);
+}
+export function wireTaskStoreSyncTriggers(taskCtx, syncCoordinator, log) {
+    const triggerSync = (eventName, taskId) => {
+        syncCoordinator.sync().catch((err) => {
+            log.warn({ err, eventName, taskId }, 'tasks:store-event sync failed');
+        });
+    };
+    const subscriptions = TASK_SYNC_TRIGGER_EVENTS.map((eventName) => {
+        const handler = (task) => {
+            const taskId = task?.id;
+            if (taskId && isDirectTaskLifecycleActive(taskId)) {
+                return;
+            }
+            triggerSync(eventName, taskId);
+        };
+        taskCtx.store.on(eventName, handler);
+        return { eventName, handler };
+    });
+    return {
+        stop() {
+            for (const sub of subscriptions) {
+                taskCtx.store.off(sub.eventName, sub.handler);
+            }
+        },
+    };
+}

package/dist/tasks/task-sync.test.js

@@ -0,0 +1,86 @@
+import { describe, expect, it, vi } from 'vitest';
+import { TaskStore } from './store.js';
+import { ensureTaskSyncCoordinator, runTaskSync, wireTaskStoreSyncTriggers, } from './task-sync.js';
+import { withDirectTaskLifecycle } from './task-lifecycle.js';
+vi.mock('./sync-coordinator.js', () => ({
+    TaskSyncCoordinator: vi.fn().mockImplementation(() => ({
+        sync: vi.fn(async () => ({
+            threadsCreated: 0,
+            emojisUpdated: 0,
+            starterMessagesUpdated: 0,
+            threadsArchived: 0,
+            statusesUpdated: 0,
+            tagsUpdated: 0,
+            warnings: 0,
+        })),
+    })),
+}));
+function makeTaskCtx() {
+    return {
+        forumId: 'forum-1',
+        tagMap: { feature: 'tag-1' },
+        tagMapPath: '/tmp/tag-map.json',
+        store: new TaskStore({ prefix: 'ws' }),
+        log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+        sidebarMentionUserId: 'user-123',
+        forumCountSync: { requestUpdate: vi.fn(), stop: vi.fn() },
+        syncFailureRetryEnabled: false,
+        syncFailureRetryDelayMs: 12_000,
+        syncDeferredRetryDelayMs: 18_000,
+    };
+}
+function makeRunCtx() {
+    return { client: {}, guild: {} };
+}
+describe('task-sync coordinator helpers', () => {
+    it('creates and reuses coordinator on task context', async () => {
+        const { TaskSyncCoordinator } = await import('./sync-coordinator.js');
+        const taskCtx = makeTaskCtx();
+        taskCtx.syncRunOptions = { skipPhase5: true };
+        const first = await ensureTaskSyncCoordinator(taskCtx, makeRunCtx());
+        const second = await ensureTaskSyncCoordinator(taskCtx, makeRunCtx());
+        expect(first).toBe(second);
+        expect(TaskSyncCoordinator).toHaveBeenCalledOnce();
+        expect(TaskSyncCoordinator).toHaveBeenCalledWith(expect.objectContaining({
+            client: expect.anything(),
+            guild: expect.anything(),
+            forumId: 'forum-1',
+            tagMapPath: '/tmp/tag-map.json',
+            mentionUserId: 'user-123',
+            skipPhase5: true,
+            enableFailureRetry: false,
+            failureRetryDelayMs: 12_000,
+            deferredRetryDelayMs: 18_000,
+        }));
+    });
+    it('runTaskSync forwards statusPoster to coordinator sync', async () => {
+        const taskCtx = makeTaskCtx();
+        const statusPoster = { taskSyncComplete: vi.fn() };
+        const result = await runTaskSync(taskCtx, makeRunCtx(), statusPoster);
+        expect(result).toEqual(expect.objectContaining({ threadsCreated: 0 }));
+        expect(taskCtx.syncCoordinator.sync).toHaveBeenCalledWith(statusPoster);
+    });
+});
+describe('wireTaskStoreSyncTriggers', () => {
+    it('wires only trigger events and skips direct-lifecycle-owned updates', async () => {
+        const taskCtx = makeTaskCtx();
+        const syncCoordinator = { sync: vi.fn(async () => null) };
+        const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+        const wired = wireTaskStoreSyncTriggers(taskCtx, syncCoordinator, log);
+        const task = taskCtx.store.create({ title: 'Test task' });
+        // created does not trigger sync
+        const callsAfterCreate = syncCoordinator.sync.mock.calls.length;
+        expect(callsAfterCreate).toBe(0);
+        // updated does trigger sync
+        taskCtx.store.update(task.id, { title: 'Updated' });
+        expect(syncCoordinator.sync.mock.calls.length).toBeGreaterThan(callsAfterCreate);
+        const callsBeforeOwnedUpdate = syncCoordinator.sync.mock.calls.length;
+        await withDirectTaskLifecycle(task.id, async () => {
+            taskCtx.store.update(task.id, { title: 'Owned update' });
+        });
+        expect(syncCoordinator.sync.mock.calls.length).toBe(callsBeforeOwnedUpdate);
+        wired.stop();
+        taskCtx.store.update(task.id, { title: 'Post-stop update' });
+        expect(syncCoordinator.sync.mock.calls.length).toBe(callsBeforeOwnedUpdate);
+    });
+});

package/dist/tasks/thread-cache.js

@@ -0,0 +1,42 @@
+import { getThreadIdFromTask } from './thread-helpers.js';
+// ---------------------------------------------------------------------------
+// Thread → task lookup
+// ---------------------------------------------------------------------------
+/** Find a task by its Discord thread ID (matches via external_ref). */
+export function findTaskByThreadId(threadId, store) {
+    const tasks = store.list({ status: 'all' });
+    return tasks.find((task) => getThreadIdFromTask(task) === threadId) ?? null;
+}
+// ---------------------------------------------------------------------------
+// In-memory TTL cache: Discord thread ID → task data
+// ---------------------------------------------------------------------------
+const DEFAULT_TTL_MS = 120_000; // 2 minutes
+export class TaskThreadCache {
+    cache = new Map();
+    ttlMs;
+    constructor(ttlMs = DEFAULT_TTL_MS) {
+        this.ttlMs = ttlMs;
+    }
+    /** Get task for a thread ID (cached or fresh). Returns null if no task matches. */
+    async get(threadId, store) {
+        const entry = this.cache.get(threadId);
+        if (entry && Date.now() - entry.fetchedAt < this.ttlMs) {
+            return entry.task;
+        }
+        const tasks = store.list({ status: 'all' });
+        const task = tasks.find((item) => getThreadIdFromTask(item) === threadId) ?? null;
+        this.cache.set(threadId, { task, fetchedAt: Date.now() });
+        return task;
+    }
+    /** Invalidate one entry or all entries. */
+    invalidate(threadId) {
+        if (threadId) {
+            this.cache.delete(threadId);
+        }
+        else {
+            this.cache.clear();
+        }
+    }
+}
+/** Module-level singleton used by the bot process. */
+export const taskThreadCache = new TaskThreadCache();

package/dist/tasks/thread-cache.test.js

@@ -0,0 +1,89 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { TaskStore } from './store.js';
+import { TaskThreadCache, taskThreadCache, findTaskByThreadId, } from './thread-cache.js';
+function makeStore(tasks) {
+    const store = new TaskStore({ prefix: 'ws' });
+    for (const { externalRef, title } of tasks) {
+        const b = store.create({ title: title ?? 'Test' });
+        store.update(b.id, { externalRef });
+    }
+    return store;
+}
+describe('TaskThreadCache', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('returns cached task within TTL', async () => {
+        const cache = new TaskThreadCache(60_000);
+        const store = makeStore([{ externalRef: 'discord:thread-1' }]);
+        const listSpy = vi.spyOn(store, 'list');
+        const first = await cache.get('thread-1', store);
+        expect(first).not.toBeNull();
+        expect(listSpy).toHaveBeenCalledTimes(1);
+        // Second call should use cache, not call store.list again.
+        const second = await cache.get('thread-1', store);
+        expect(second?.id).toBe(first?.id);
+        expect(listSpy).toHaveBeenCalledTimes(1);
+    });
+    it('refetches after TTL expires', async () => {
+        const cache = new TaskThreadCache(0); // 0ms TTL = always expired
+        const store = makeStore([{ externalRef: 'discord:thread-1' }]);
+        const listSpy = vi.spyOn(store, 'list');
+        const first = await cache.get('thread-1', store);
+        expect(first).not.toBeNull();
+        const second = await cache.get('thread-1', store);
+        expect(second?.id).toBe(first?.id);
+        expect(listSpy).toHaveBeenCalledTimes(2);
+    });
+    it('invalidate() clears all entries', async () => {
+        const cache = new TaskThreadCache(60_000);
+        const store = makeStore([
+            { externalRef: 'discord:thread-1' },
+            { externalRef: 'discord:thread-2' },
+        ]);
+        const listSpy = vi.spyOn(store, 'list');
+        await cache.get('thread-1', store);
+        await cache.get('thread-2', store);
+        expect(listSpy).toHaveBeenCalledTimes(2);
+        cache.invalidate();
+        await cache.get('thread-1', store);
+        expect(listSpy).toHaveBeenCalledTimes(3);
+    });
+    it('invalidate(threadId) clears single entry', async () => {
+        const cache = new TaskThreadCache(60_000);
+        const store = makeStore([
+            { externalRef: 'discord:thread-1' },
+            { externalRef: 'discord:thread-2' },
+        ]);
+        const listSpy = vi.spyOn(store, 'list');
+        await cache.get('thread-1', store);
+        await cache.get('thread-2', store);
+        expect(listSpy).toHaveBeenCalledTimes(2);
+        cache.invalidate('thread-1');
+        // thread-1 should refetch, thread-2 should still be cached.
+        await cache.get('thread-1', store);
+        await cache.get('thread-2', store);
+        expect(listSpy).toHaveBeenCalledTimes(3);
+    });
+    it('returns null when no task matches', async () => {
+        const cache = new TaskThreadCache(60_000);
+        const store = new TaskStore();
+        const result = await cache.get('thread-1', store);
+        expect(result).toBeNull();
+    });
+    it('caches null results (negative cache)', async () => {
+        const cache = new TaskThreadCache(60_000);
+        const store = new TaskStore();
+        const listSpy = vi.spyOn(store, 'list');
+        const first = await cache.get('thread-1', store);
+        expect(first).toBeNull();
+        const second = await cache.get('thread-1', store);
+        expect(second).toBeNull();
+        // Only one store.list call — the null was cached.
+        expect(listSpy).toHaveBeenCalledTimes(1);
+    });
+    it('exposes module-level singleton and lookup export', () => {
+        expect(taskThreadCache).toBeInstanceOf(TaskThreadCache);
+        expect(typeof findTaskByThreadId).toBe('function');
+    });
+});