discoclaw 0.1.0

package/dist/cron/cron-sync.test.js

@@ -0,0 +1,228 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ChannelType } from 'discord.js';
+import { runCronSync } from './cron-sync.js';
+function makeMockRuntime(output) {
+    return {
+        id: 'other',
+        capabilities: new Set(),
+        async *invoke() {
+            yield { type: 'text_final', text: output };
+        },
+    };
+}
+function mockLog() {
+    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+}
+function makeRecord(overrides) {
+    return {
+        cronId: 'cron-test1',
+        threadId: 'thread-1',
+        runCount: 0,
+        lastRunAt: null,
+        lastRunStatus: null,
+        cadence: null,
+        purposeTags: [],
+        disabled: false,
+        model: null,
+        ...overrides,
+    };
+}
+function makeStatsStore(records) {
+    const store = {};
+    for (const r of records)
+        store[r.cronId] = r;
+    return {
+        getStore: () => ({ version: 1, updatedAt: Date.now(), jobs: store }),
+        getRecord: (id) => store[id],
+        getRecordByThreadId: (tid) => Object.values(store).find((r) => r.threadId === tid),
+        upsertRecord: vi.fn(async (cronId, threadId, updates) => {
+            const existing = store[cronId] ?? makeRecord({ cronId, threadId });
+            if (updates)
+                Object.assign(existing, updates);
+            store[cronId] = existing;
+            return existing;
+        }),
+        recordRun: vi.fn(async () => { }),
+        removeRecord: vi.fn(async () => true),
+        removeByThreadId: vi.fn(async () => true),
+    };
+}
+function makeScheduler(jobs) {
+    return {
+        listJobs: () => jobs.map((j) => ({ id: j.id, name: j.name, schedule: j.schedule, timezone: 'UTC', nextRun: null })),
+        getJob: (id) => {
+            const j = jobs.find((jj) => jj.id === id);
+            if (!j)
+                return undefined;
+            return { id: j.id, cronId: j.cronId, threadId: j.threadId, guildId: 'g1', name: j.name, def: { schedule: j.schedule, timezone: 'UTC', channel: 'general', prompt: j.prompt }, cron: null, running: false };
+        },
+    };
+}
+function makeForum(threads) {
+    const threadMap = new Map(threads.map((t) => [t.id, { ...t, appliedTags: t.appliedTags ?? [], edit: vi.fn(), setName: vi.fn() }]));
+    return {
+        id: 'forum-1',
+        type: ChannelType.GuildForum,
+        threads: {
+            fetchActive: vi.fn(async () => ({ threads: threadMap })),
+        },
+    };
+}
+function makeClient(forum) {
+    return {
+        channels: {
+            cache: { get: (id) => id === forum.id ? forum : undefined },
+            fetch: vi.fn(async (id) => id === forum.id ? forum : null),
+        },
+    };
+}
+const defaultTagMap = {
+    monitoring: 'tag-1',
+    cleanup: 'tag-2',
+    daily: 'tag-3',
+    weekly: 'tag-4',
+};
+// Mock ensureStatusMessage (from the cron discord-sync)
+vi.mock('./discord-sync.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        ensureStatusMessage: vi.fn(async () => 'msg-1'),
+    };
+});
+describe('runCronSync', () => {
+    it('returns zeros when forum not found', async () => {
+        const client = { channels: { cache: { get: () => undefined }, fetch: vi.fn(async () => null) } };
+        const result = await runCronSync({
+            client: client,
+            forumId: 'missing',
+            scheduler: makeScheduler([]),
+            statsStore: makeStatsStore([]),
+            runtime: makeMockRuntime('monitoring'),
+            tagMap: { ...defaultTagMap },
+            autoTag: true,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log: mockLog(),
+            throttleMs: 0,
+        });
+        expect(result.tagsApplied).toBe(0);
+        expect(result.namesUpdated).toBe(0);
+    });
+    it('phase 1: applies tags to threads missing them', async () => {
+        const forum = makeForum([{ id: 'thread-1', name: 'Test Job', parentId: 'forum-1' }]);
+        const client = makeClient(forum);
+        const record = makeRecord({ cronId: 'cron-1', threadId: 'thread-1' });
+        const scheduler = makeScheduler([{ id: 'thread-1', threadId: 'thread-1', cronId: 'cron-1', name: 'Test Job', schedule: '0 7 * * *', prompt: 'Monitor health' }]);
+        const result = await runCronSync({
+            client: client,
+            forumId: 'forum-1',
+            scheduler,
+            statsStore: makeStatsStore([record]),
+            runtime: makeMockRuntime('monitoring'),
+            tagMap: { ...defaultTagMap },
+            autoTag: true,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log: mockLog(),
+            throttleMs: 0,
+        });
+        expect(result.tagsApplied).toBe(1);
+    });
+    it('phase 1: reconciles applied tags when tag-map IDs change', async () => {
+        const forum = makeForum([{ id: 'thread-1', name: 'Test Job', parentId: 'forum-1', appliedTags: ['old-tag', 'daily-old'] }]);
+        const client = makeClient(forum);
+        const record = makeRecord({
+            cronId: 'cron-1',
+            threadId: 'thread-1',
+            cadence: 'daily',
+            purposeTags: ['monitoring'],
+            model: 'fast',
+        });
+        const scheduler = makeScheduler([{ id: 'thread-1', threadId: 'thread-1', cronId: 'cron-1', name: 'Test Job', schedule: '0 7 * * *', prompt: 'Monitor health' }]);
+        const result = await runCronSync({
+            client: client,
+            forumId: 'forum-1',
+            scheduler,
+            statsStore: makeStatsStore([record]),
+            runtime: makeMockRuntime('monitoring'),
+            tagMap: { ...defaultTagMap },
+            autoTag: true,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log: mockLog(),
+            throttleMs: 0,
+        });
+        expect(result.tagsApplied).toBe(1);
+        const thread = (await forum.threads.fetchActive()).threads.get('thread-1');
+        expect(thread.edit).toHaveBeenCalledWith({ appliedTags: ['tag-1', 'tag-3'] });
+    });
+    it('phase 2: updates thread names with cadence emoji', async () => {
+        const forum = makeForum([{ id: 'thread-2', name: 'Old Name', parentId: 'forum-1' }]);
+        const client = makeClient(forum);
+        const record = makeRecord({ cronId: 'cron-2', threadId: 'thread-2', cadence: 'daily', purposeTags: ['monitoring'], model: 'haiku' });
+        const scheduler = makeScheduler([{ id: 'thread-2', threadId: 'thread-2', cronId: 'cron-2', name: 'Daily Check', schedule: '0 7 * * *', prompt: 'Check things' }]);
+        const result = await runCronSync({
+            client: client,
+            forumId: 'forum-1',
+            scheduler,
+            statsStore: makeStatsStore([record]),
+            runtime: makeMockRuntime('monitoring'),
+            tagMap: { ...defaultTagMap },
+            autoTag: false,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log: mockLog(),
+            throttleMs: 0,
+        });
+        expect(result.namesUpdated).toBe(1);
+    });
+    it('continues with metadata/status phases when fetchActive fails', async () => {
+        const forum = makeForum([]);
+        forum.threads.fetchActive.mockRejectedValueOnce(new Error('Discord API failure'));
+        const client = makeClient(forum);
+        const log = mockLog();
+        const record = makeRecord({ cronId: 'cron-3', threadId: 'thread-3', cadence: 'daily', model: 'haiku' });
+        const scheduler = makeScheduler([
+            { id: 'thread-3', threadId: 'thread-3', cronId: 'cron-3', name: 'Daily Check', schedule: '0 7 * * *', prompt: 'Check things' },
+        ]);
+        const result = await runCronSync({
+            client: client,
+            forumId: 'forum-1',
+            scheduler,
+            statsStore: makeStatsStore([record]),
+            runtime: makeMockRuntime('monitoring'),
+            tagMap: { ...defaultTagMap },
+            autoTag: false,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log,
+            throttleMs: 0,
+        });
+        expect(result.tagsApplied).toBe(0);
+        expect(result.namesUpdated).toBe(0);
+        expect(result.statusMessagesUpdated).toBe(1);
+        expect(result.orphansDetected).toBe(0);
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ err: expect.any(Error), forumId: 'forum-1' }), expect.stringContaining('failed to fetch active threads'));
+    });
+    it('phase 4: detects orphan threads', async () => {
+        const forum = makeForum([{ id: 'thread-orphan', name: 'Orphan', parentId: 'forum-1' }]);
+        const client = makeClient(forum);
+        const log = mockLog();
+        const result = await runCronSync({
+            client: client,
+            forumId: 'forum-1',
+            scheduler: makeScheduler([]),
+            statsStore: makeStatsStore([]),
+            runtime: makeMockRuntime(''),
+            tagMap: { ...defaultTagMap },
+            autoTag: false,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log,
+            throttleMs: 0,
+        });
+        expect(result.orphansDetected).toBe(1);
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ threadId: 'thread-orphan' }), expect.stringContaining('orphan'));
+    });
+});

package/dist/cron/cron-tag-map-watcher.js

@@ -0,0 +1,128 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+const DEFAULT_DEBOUNCE_MS = 2000;
+const DEFAULT_POLL_FALLBACK_MS = 30_000;
+const DIR_POLL_MS = 30_000;
+/**
+ * Watch tag-map.json for changes and trigger coordinator.sync() on change.
+ * Mirrors the tag-map watching portion of TaskSyncWatcher but triggers a
+ * full coordinator sync (reload + runCronSync) instead of just a reload.
+ *
+ * Uses fs.watch on the parent directory (atomic-write safe) with a stat-based
+ * polling fallback for platforms where fs.watch is unreliable.
+ * If the parent directory doesn't exist yet, polls until it appears.
+ */
+export function startCronTagMapWatcher(opts) {
+    const { coordinator, tagMapPath, log } = opts;
+    const debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    const pollFallbackMs = opts.pollFallbackMs ?? DEFAULT_POLL_FALLBACK_MS;
+    const tagMapDir = path.dirname(tagMapPath);
+    const tagMapBase = path.basename(tagMapPath);
+    let stopped = false;
+    let watcher = null;
+    let debounceTimer = null;
+    let pollTimer = null;
+    let dirPollTimer = null;
+    let lastMtimeMs = 0;
+    let mtimeSeeded = false;
+    function clearDebounce() {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+            debounceTimer = null;
+        }
+    }
+    function scheduleDebouncedSync() {
+        clearDebounce();
+        debounceTimer = setTimeout(() => {
+            debounceTimer = null;
+            if (stopped)
+                return;
+            coordinator.sync().catch((err) => {
+                log?.warn({ err }, 'cron:tag-map-watcher sync failed');
+            });
+        }, debounceMs);
+    }
+    function startWatching() {
+        // Primary: fs.watch on parent directory, filtered by basename
+        try {
+            watcher = fs.watch(tagMapDir, (_eventType, filename) => {
+                if (stopped)
+                    return;
+                if (filename === tagMapBase) {
+                    scheduleDebouncedSync();
+                }
+            });
+            watcher.on('error', (err) => {
+                log?.warn({ err }, 'cron:tag-map-watcher fs.watch error; polling fallback continues');
+            });
+        }
+        catch {
+            // fs.watch not available — polling alone.
+        }
+        // Seed initial mtime before starting poll to avoid spurious first-poll trigger
+        fsp.stat(tagMapPath).then((s) => {
+            lastMtimeMs = s.mtimeMs;
+        }).catch(() => { }).finally(() => { mtimeSeeded = true; });
+        // Polling fallback: check stat.mtimeMs
+        pollTimer = setInterval(async () => {
+            if (stopped || !mtimeSeeded)
+                return;
+            try {
+                const s = await fsp.stat(tagMapPath);
+                if (s.mtimeMs > lastMtimeMs) {
+                    lastMtimeMs = s.mtimeMs;
+                    scheduleDebouncedSync();
+                }
+            }
+            catch {
+                // stat failed — ignore.
+            }
+        }, pollFallbackMs);
+    }
+    // If parent directory exists, start watching immediately.
+    // Otherwise, poll until it appears.
+    fsp.access(tagMapDir).then(() => {
+        if (!stopped)
+            startWatching();
+    }).catch(() => {
+        // Directory doesn't exist yet — poll for it.
+        dirPollTimer = setInterval(async () => {
+            if (stopped)
+                return;
+            try {
+                await fsp.access(tagMapDir);
+                // Directory appeared — start watching and stop polling.
+                if (dirPollTimer) {
+                    clearInterval(dirPollTimer);
+                    dirPollTimer = null;
+                }
+                if (!stopped)
+                    startWatching();
+            }
+            catch {
+                // Still doesn't exist — keep polling.
+            }
+        }, DIR_POLL_MS);
+    });
+    return {
+        stop() {
+            if (stopped)
+                return;
+            stopped = true;
+            clearDebounce();
+            if (watcher) {
+                watcher.close();
+                watcher = null;
+            }
+            if (pollTimer) {
+                clearInterval(pollTimer);
+                pollTimer = null;
+            }
+            if (dirPollTimer) {
+                clearInterval(dirPollTimer);
+                dirPollTimer = null;
+            }
+        },
+    };
+}

package/dist/cron/cron-tag-map-watcher.test.js

@@ -0,0 +1,155 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import { startCronTagMapWatcher } from './cron-tag-map-watcher.js';
+vi.mock('node:fs');
+vi.mock('node:fs/promises');
+const mockAccess = vi.mocked(fsp.access);
+const mockStat = vi.mocked(fsp.stat);
+const mockWatch = vi.mocked(fs.watch);
+function mockLog() {
+    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+}
+function makeCoordinator() {
+    return {
+        sync: vi.fn(async () => ({ tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, orphansDetected: 0 })),
+    };
+}
+describe('startCronTagMapWatcher', () => {
+    let watchCallback = null;
+    let watcherObj;
+    beforeEach(() => {
+        vi.resetAllMocks();
+        vi.useFakeTimers();
+        watchCallback = null;
+        watcherObj = { close: vi.fn(), on: vi.fn() };
+        mockWatch.mockImplementation((_path, callback) => {
+            watchCallback = callback;
+            return watcherObj;
+        });
+        // Default: directory exists, file has mtime
+        mockAccess.mockResolvedValue(undefined);
+        mockStat.mockResolvedValue({ mtimeMs: 1000 });
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('change event triggers debounced coordinator.sync()', async () => {
+        const coordinator = makeCoordinator();
+        const handle = startCronTagMapWatcher({
+            coordinator,
+            tagMapPath: '/data/tag-map.json',
+            log: mockLog(),
+            debounceMs: 100,
+        });
+        // Let access/stat promises resolve
+        await vi.advanceTimersByTimeAsync(0);
+        // Simulate file change
+        watchCallback?.('change', 'tag-map.json');
+        expect(coordinator.sync).not.toHaveBeenCalled();
+        // Advance past debounce
+        await vi.advanceTimersByTimeAsync(100);
+        expect(coordinator.sync).toHaveBeenCalledTimes(1);
+        handle.stop();
+    });
+    it('multiple rapid events debounce to single sync', async () => {
+        const coordinator = makeCoordinator();
+        const handle = startCronTagMapWatcher({
+            coordinator,
+            tagMapPath: '/data/tag-map.json',
+            log: mockLog(),
+            debounceMs: 200,
+        });
+        await vi.advanceTimersByTimeAsync(0);
+        watchCallback?.('change', 'tag-map.json');
+        watchCallback?.('change', 'tag-map.json');
+        watchCallback?.('change', 'tag-map.json');
+        await vi.advanceTimersByTimeAsync(200);
+        expect(coordinator.sync).toHaveBeenCalledTimes(1);
+        handle.stop();
+    });
+    it('ignores changes to unrelated files', async () => {
+        const coordinator = makeCoordinator();
+        const handle = startCronTagMapWatcher({
+            coordinator,
+            tagMapPath: '/data/tag-map.json',
+            log: mockLog(),
+            debounceMs: 100,
+        });
+        await vi.advanceTimersByTimeAsync(0);
+        watchCallback?.('change', 'other-file.json');
+        await vi.advanceTimersByTimeAsync(200);
+        expect(coordinator.sync).not.toHaveBeenCalled();
+        handle.stop();
+    });
+    it('polling fallback detects mtime change', async () => {
+        // No fs.watch available
+        mockWatch.mockImplementation(() => { throw new Error('not available'); });
+        const coordinator = makeCoordinator();
+        const handle = startCronTagMapWatcher({
+            coordinator,
+            tagMapPath: '/data/tag-map.json',
+            log: mockLog(),
+            debounceMs: 100,
+            pollFallbackMs: 500,
+        });
+        // Let access resolve + seed mtime
+        await vi.advanceTimersByTimeAsync(0);
+        // Simulate mtime change on next poll
+        mockStat.mockResolvedValue({ mtimeMs: 2000 });
+        await vi.advanceTimersByTimeAsync(500);
+        // Advance past debounce
+        await vi.advanceTimersByTimeAsync(100);
+        expect(coordinator.sync).toHaveBeenCalledTimes(1);
+        handle.stop();
+    });
+    it('dir-missing startup polls until dir appears', async () => {
+        // Directory missing initially
+        mockAccess.mockRejectedValueOnce(new Error('ENOENT'));
+        const coordinator = makeCoordinator();
+        const handle = startCronTagMapWatcher({
+            coordinator,
+            tagMapPath: '/data/tag-map.json',
+            log: mockLog(),
+            debounceMs: 100,
+        });
+        await vi.advanceTimersByTimeAsync(0);
+        // Directory appears on next dir-poll cycle
+        mockAccess.mockResolvedValue(undefined);
+        await vi.advanceTimersByTimeAsync(30_000);
+        // Now fs.watch should be set up and a change should work
+        if (watchCallback) {
+            watchCallback('change', 'tag-map.json');
+            await vi.advanceTimersByTimeAsync(100);
+            expect(coordinator.sync).toHaveBeenCalled();
+        }
+        handle.stop();
+    });
+    it('stop() prevents further syncs', async () => {
+        const coordinator = makeCoordinator();
+        const handle = startCronTagMapWatcher({
+            coordinator,
+            tagMapPath: '/data/tag-map.json',
+            log: mockLog(),
+            debounceMs: 100,
+        });
+        await vi.advanceTimersByTimeAsync(0);
+        handle.stop();
+        watchCallback?.('change', 'tag-map.json');
+        await vi.advanceTimersByTimeAsync(200);
+        expect(coordinator.sync).not.toHaveBeenCalled();
+    });
+    it('stop() is idempotent', async () => {
+        const coordinator = makeCoordinator();
+        const handle = startCronTagMapWatcher({
+            coordinator,
+            tagMapPath: '/data/tag-map.json',
+            log: mockLog(),
+            debounceMs: 100,
+        });
+        await vi.advanceTimersByTimeAsync(0);
+        handle.stop();
+        handle.stop(); // second call should not throw
+        expect(watcherObj.close).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/cron/default-timezone.js

@@ -0,0 +1,23 @@
+/**
+ * Returns the default timezone using a fallback chain:
+ * 1. process.env.DEFAULT_TIMEZONE (if set and valid)
+ * 2. Intl.DateTimeFormat().resolvedOptions().timeZone (system timezone)
+ *
+ * Invalid DEFAULT_TIMEZONE values are logged and skipped.
+ */
+export function getDefaultTimezone() {
+    const envTz = process.env.DEFAULT_TIMEZONE;
+    if (envTz) {
+        try {
+            // Validate by attempting to construct a formatter with this timezone.
+            Intl.DateTimeFormat(undefined, { timeZone: envTz });
+            return envTz;
+        }
+        catch {
+            // Invalid IANA timezone in env var — fall through to system detection.
+            // Log to stderr so the operator sees the misconfiguration.
+            console.error(`[cron] DEFAULT_TIMEZONE="${envTz}" is not a valid IANA timezone; falling back to system timezone.`);
+        }
+    }
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}

package/dist/cron/default-timezone.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it, vi, afterEach } from 'vitest';
+import { getDefaultTimezone } from './default-timezone.js';
+describe('getDefaultTimezone', () => {
+    afterEach(() => {
+        vi.unstubAllEnvs();
+    });
+    it('returns DEFAULT_TIMEZONE when set to a valid IANA timezone', () => {
+        vi.stubEnv('DEFAULT_TIMEZONE', 'America/New_York');
+        expect(getDefaultTimezone()).toBe('America/New_York');
+    });
+    it('falls back to system timezone when env var is not set', () => {
+        vi.stubEnv('DEFAULT_TIMEZONE', '');
+        const systemTz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        expect(getDefaultTimezone()).toBe(systemTz);
+    });
+    it('falls back to system timezone and logs error for invalid DEFAULT_TIMEZONE', () => {
+        vi.stubEnv('DEFAULT_TIMEZONE', 'NotATimezone');
+        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const systemTz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        expect(getDefaultTimezone()).toBe(systemTz);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('NotATimezone'));
+        consoleSpy.mockRestore();
+    });
+    it('always returns a non-empty string', () => {
+        vi.stubEnv('DEFAULT_TIMEZONE', '');
+        const result = getDefaultTimezone();
+        expect(typeof result).toBe('string');
+        expect(result.length).toBeGreaterThan(0);
+    });
+});