discoclaw 0.1.0

package/dist/tasks/thread-forum-ops.js

@@ -0,0 +1,68 @@
+import { TaskDiscordChannelType, } from './discord-types.js';
+import { buildAppliedTagsWithStatus, buildTaskStarterContent, buildThreadName, taskIdToken, } from './thread-helpers.js';
+// ---------------------------------------------------------------------------
+// Forum channel resolution
+// ---------------------------------------------------------------------------
+/** Resolve a forum channel by name or ID in a specific guild (multi-guild safe). */
+export async function resolveTasksForum(guild, nameOrId) {
+    // Fast path: cached by ID.
+    const byId = guild.channels.cache.get(nameOrId);
+    if (byId && byId.type === TaskDiscordChannelType.GuildForum)
+        return byId;
+    // If it's an ID, try fetching directly (covers cache misses).
+    try {
+        const fetched = await guild.channels.fetch(nameOrId);
+        if (fetched && fetched.type === TaskDiscordChannelType.GuildForum)
+            return fetched;
+    }
+    catch {
+        // Not an ID or fetch failed; fall through to name lookup.
+    }
+    const want = nameOrId.toLowerCase();
+    const ch = guild.channels.cache.find((c) => c.type === TaskDiscordChannelType.GuildForum && c.name.toLowerCase() === want);
+    return ch ?? null;
+}
+/** Create a new forum thread for a task. Returns the thread ID. */
+export async function createTaskThread(forum, task, tagMap, mentionUserId) {
+    const name = buildThreadName(task.id, task.title, task.status);
+    // Resolve forum tag IDs from task labels.
+    const appliedTagIds = [];
+    for (const label of task.labels ?? []) {
+        // Try the label directly, then strip common prefixes (tag:, label:).
+        const cleaned = label.replace(/^(tag|label):/, '');
+        const tagId = tagMap[cleaned] ?? tagMap[label];
+        if (tagId)
+            appliedTagIds.push(tagId);
+    }
+    const uniqueTagIds = buildAppliedTagsWithStatus([...new Set(appliedTagIds)], task.status, tagMap);
+    const message = buildTaskStarterContent(task, mentionUserId).slice(0, 2000);
+    const thread = await forum.threads.create({
+        name,
+        message: {
+            content: message,
+            // Prevent accidental @everyone/@here from task descriptions.
+            allowedMentions: { parse: [], users: mentionUserId ? [mentionUserId] : [] },
+        },
+        appliedTags: uniqueTagIds,
+    });
+    return thread.id;
+}
+export async function findExistingThreadForTask(forum, taskId, opts) {
+    const token = taskIdToken(taskId);
+    const archivedLimit = Math.max(1, Math.min(100, opts?.archivedLimit ?? 100));
+    const active = await forum.threads.fetchActive();
+    const archived = await forum.threads.fetchArchived({ limit: archivedLimit, fetchAll: true });
+    const all = [...active.threads.values(), ...archived.threads.values()];
+    const matches = all.filter((t) => typeof t?.name === 'string' && t.name.includes(token));
+    if (matches.length === 0)
+        return null;
+    // Prefer active (non-archived) threads; among ties, pick the newest (highest snowflake ID).
+    const sorted = [...matches].sort((a, b) => {
+        const aActive = a.archived ? 0 : 1;
+        const bActive = b.archived ? 0 : 1;
+        if (aActive !== bActive)
+            return bActive - aActive;
+        return BigInt(b.id) > BigInt(a.id) ? 1 : -1;
+    });
+    return sorted[0].id;
+}

package/dist/tasks/thread-helpers.js

@@ -0,0 +1,86 @@
+import { STATUS_EMOJI, TASK_STATUSES } from './types.js';
+const THREAD_NAME_MAX = 100;
+/** Strip the project prefix from a task ID: `ws-001` → `001`. */
+export function shortTaskId(id) {
+    const idx = id.indexOf('-');
+    return idx >= 0 ? id.slice(idx + 1) : id;
+}
+/** Build a thread name: `{emoji} [{shortId}] {title}`, capped at 100 chars. */
+export function buildThreadName(taskId, title, status) {
+    const emoji = STATUS_EMOJI[status] ?? STATUS_EMOJI.open;
+    const prefix = `${emoji} [${shortTaskId(taskId)}] `;
+    const maxTitle = THREAD_NAME_MAX - prefix.length;
+    const trimmedTitle = title.length > maxTitle ? title.slice(0, maxTitle - 1) + '\u2026' : title;
+    return `${prefix}${trimmedTitle}`;
+}
+export function taskIdToken(taskId) {
+    return `[${shortTaskId(taskId)}]`;
+}
+const emojiPrefix = Object.values(STATUS_EMOJI).map(e => e.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')).join('|');
+const TASK_THREAD_PATTERN = new RegExp(`^(?:${emojiPrefix})\\s*\\[(\\d+)\\]`);
+/**
+ * Extract the short numeric ID from a thread name that starts with a
+ * recognised task status emoji followed by `[NNN]`.
+ * Returns the numeric string, or null if the name doesn't match.
+ */
+export function extractShortIdFromThreadName(name) {
+    const m = TASK_THREAD_PATTERN.exec(name);
+    return m ? m[1] : null;
+}
+/**
+ * Extract the Discord thread ID from a task's external_ref field.
+ * Supports formats:
+ *   - `discord:<threadId>`
+ *   - raw numeric ID
+ */
+export function getThreadIdFromTask(task) {
+    const ref = (task.external_ref ?? '').trim();
+    if (!ref)
+        return null;
+    if (ref.startsWith('discord:'))
+        return ref.slice('discord:'.length).trim() || null;
+    if (/^\d+$/.test(ref))
+        return ref;
+    return null;
+}
+/** Returns the set of Discord tag IDs that correspond to task statuses. */
+export function getStatusTagIds(tagMap) {
+    const ids = new Set();
+    for (const status of TASK_STATUSES) {
+        const id = tagMap[status];
+        if (id)
+            ids.add(id);
+    }
+    return ids;
+}
+/**
+ * Strip old status tags, add the new one, preserve content tags.
+ * Status tag gets priority: up to 4 content tags + 1 status tag.
+ * If no status tag ID exists in tagMap, content tags get all 5 slots.
+ */
+export function buildAppliedTagsWithStatus(currentTagIds, status, tagMap) {
+    const statusIds = getStatusTagIds(tagMap);
+    const uniqueContent = [...new Set(currentTagIds.filter(id => !statusIds.has(id)))];
+    const newStatusId = tagMap[status];
+    if (newStatusId) {
+        return [...uniqueContent.slice(0, 4), newStatusId];
+    }
+    return uniqueContent.slice(0, 5);
+}
+/** Build the starter message content for a task thread. */
+export function buildTaskStarterContent(task, mentionUserId) {
+    const lines = [];
+    if (task.description)
+        lines.push(task.description);
+    lines.push('');
+    lines.push(`**ID:** \`${task.id}\``);
+    lines.push(`**Priority:** P${task.priority ?? 2}`);
+    lines.push(`**Status:** ${task.status}`);
+    if (task.owner)
+        lines.push(`**Owner:** ${task.owner}`);
+    if (mentionUserId) {
+        lines.push('');
+        lines.push(`<@${mentionUserId}>`);
+    }
+    return lines.join('\n');
+}

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

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { buildAppliedTagsWithStatus, buildTaskStarterContent, buildThreadName, extractShortIdFromThreadName, getStatusTagIds, getThreadIdFromTask, shortTaskId, taskIdToken, } from './thread-helpers.js';
+describe('thread-helpers', () => {
+    it('builds thread names and short-id tokens', () => {
+        expect(buildThreadName('ws-001', 'Fix login bug', 'open')).toContain('[001]');
+        expect(shortTaskId('ws-010')).toBe('010');
+        expect(taskIdToken('ws-010')).toBe('[010]');
+    });
+    it('extracts short ID from canonical thread names', () => {
+        expect(extractShortIdFromThreadName('\u{1F7E1} [042] Add feature')).toBe('042');
+        expect(extractShortIdFromThreadName('No match')).toBeNull();
+    });
+    it('extracts thread ID from external_ref', () => {
+        const task = { external_ref: 'discord:123456789' };
+        expect(getThreadIdFromTask(task)).toBe('123456789');
+        expect(getThreadIdFromTask({ external_ref: 'gh-123' })).toBeNull();
+    });
+    it('computes status tag IDs and applies status priority', () => {
+        const tagMap = { open: 's1', closed: 's2', feature: 'c1' };
+        expect(getStatusTagIds(tagMap)).toEqual(new Set(['s1', 's2']));
+        const updated = buildAppliedTagsWithStatus(['c1', 's1'], 'closed', tagMap);
+        expect(updated).toContain('s2');
+        expect(updated).not.toContain('s1');
+    });
+    it('builds starter content with optional mention', () => {
+        const task = { id: 'ws-001', status: 'open', priority: 2, description: 'A test task', owner: '' };
+        const plain = buildTaskStarterContent(task);
+        const mentioned = buildTaskStarterContent(task, '999888777');
+        expect(plain).toContain('**ID:** `ws-001`');
+        expect(plain).not.toContain('<@999888777>');
+        expect(mentioned).toContain('<@999888777>');
+    });
+});

package/dist/tasks/thread-lifecycle-ops.js

@@ -0,0 +1,144 @@
+import { buildAppliedTagsWithStatus, buildTaskStarterContent, buildThreadName, getStatusTagIds, } from './thread-helpers.js';
+import { fetchThreadChannel, tagsEqual } from './thread-ops-shared.js';
+/** Post a close summary, rename with checkmark, and archive the thread. */
+export async function closeTaskThread(client, threadId, task, tagMap, log) {
+    const thread = await fetchThreadChannel(client, threadId);
+    if (!thread)
+        return;
+    // Ensure the thread is modifiable even if it was archived previously.
+    try {
+        if (thread.archived)
+            await thread.setArchived(false);
+    }
+    catch {
+        // Ignore unarchive failures.
+    }
+    const closedName = buildThreadName(task.id, task.title, task.status);
+    // Remove mention from starter message to clear sidebar visibility.
+    try {
+        const starter = await thread.fetchStarterMessage();
+        if (starter && starter.author.id === client.user?.id) {
+            const cleanContent = buildTaskStarterContent(task);
+            if (starter.content !== cleanContent) {
+                await starter.edit({
+                    content: cleanContent.slice(0, 2000),
+                    allowedMentions: { parse: [], users: [] },
+                });
+            }
+        }
+    }
+    catch { /* ignore — close should still proceed */ }
+    const reason = task.close_reason || 'Closed';
+    try {
+        await thread.send({
+            content: `**Task Closed**\n${reason}`,
+            allowedMentions: { parse: [], users: [] },
+        });
+    }
+    catch {
+        // Ignore send failures (thread may already be archived).
+    }
+    const editPayload = { name: closedName };
+    if (tagMap) {
+        const current = thread.appliedTags ?? [];
+        const updated = buildAppliedTagsWithStatus(current, task.status, tagMap);
+        if (!tagsEqual(current, updated)) {
+            editPayload.appliedTags = updated;
+        }
+    }
+    try {
+        await thread.edit(editPayload);
+    }
+    catch (err) {
+        log?.warn({ err, taskId: task.id, threadId }, 'closeTaskThread: edit failed');
+    }
+    try {
+        await thread.setArchived(true);
+    }
+    catch {
+        // Ignore archive failures.
+    }
+}
+/** Check if a thread is archived. Returns true if the thread is archived or doesn't exist. */
+export async function isThreadArchived(client, threadId) {
+    const thread = await fetchThreadChannel(client, threadId);
+    if (!thread)
+        return true; // Thread doesn't exist — treat as archived.
+    return thread.archived === true;
+}
+/** Check if a task thread is already in its final closed state (archived + correct name + correct tags). */
+export async function isTaskThreadAlreadyClosed(client, threadId, task, tagMap) {
+    const thread = await fetchThreadChannel(client, threadId);
+    if (!thread)
+        return true; // Thread doesn't exist — nothing to close.
+    const closedName = buildThreadName(task.id, task.title, task.status);
+    if (thread.archived !== true || thread.name !== closedName)
+        return false;
+    // If tagMap provided, verify tags match expected closed state.
+    if (tagMap && getStatusTagIds(tagMap).size > 0) {
+        const current = thread.appliedTags ?? [];
+        const expected = buildAppliedTagsWithStatus(current, task.status, tagMap);
+        if (!tagsEqual(current, expected))
+            return false;
+    }
+    return true;
+}
+/** Update a thread's name to reflect current task state. */
+export async function updateTaskThreadName(client, threadId, task) {
+    const thread = await fetchThreadChannel(client, threadId);
+    if (!thread)
+        return false;
+    const newName = buildThreadName(task.id, task.title, task.status);
+    const current = thread.name;
+    if (current === newName)
+        return false;
+    await thread.setName(newName);
+    return true;
+}
+/** Update a thread's starter message to reflect current task state. When mentionUserId is provided, the mention is included for sidebar visibility. */
+export async function updateTaskStarterMessage(client, threadId, task, mentionUserId) {
+    const thread = await fetchThreadChannel(client, threadId);
+    if (!thread)
+        return false;
+    let starter;
+    try {
+        starter = await thread.fetchStarterMessage();
+    }
+    catch {
+        return false;
+    }
+    if (!starter)
+        return false;
+    // Only edit messages authored by the bot.
+    if (starter.author.id !== client.user?.id)
+        return false;
+    const newContent = buildTaskStarterContent(task, mentionUserId);
+    if (starter.content === newContent)
+        return false;
+    await starter.edit({
+        content: newContent.slice(0, 2000),
+        allowedMentions: { parse: [], users: mentionUserId ? [mentionUserId] : [] },
+    });
+    return true;
+}
+/** Update a thread's forum tags to reflect current task status. */
+export async function updateTaskThreadTags(client, threadId, task, tagMap) {
+    const thread = await fetchThreadChannel(client, threadId);
+    if (!thread)
+        return false;
+    const current = thread.appliedTags ?? [];
+    const updated = buildAppliedTagsWithStatus(current, task.status, tagMap);
+    if (tagsEqual(current, updated))
+        return false;
+    await thread.edit({ appliedTags: updated });
+    return true;
+}
+/** Unarchive a thread if it's currently archived. */
+export async function ensureUnarchived(client, threadId) {
+    const thread = await fetchThreadChannel(client, threadId);
+    if (!thread)
+        return;
+    if (thread.archived) {
+        await thread.setArchived(false);
+    }
+}

package/dist/tasks/thread-ops-shared.js

@@ -0,0 +1,21 @@
+export async function fetchThreadChannel(client, threadId) {
+    const cached = client.channels.cache.get(threadId);
+    if (cached && cached.isThread())
+        return cached;
+    try {
+        const fetched = await client.channels.fetch(threadId);
+        if (fetched && fetched.isThread())
+            return fetched;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Order-insensitive comparison of two tag ID arrays. */
+export function tagsEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const sorted = (arr) => [...arr].sort();
+    return sorted(a).every((v, i) => v === sorted(b)[i]);
+}

package/dist/tasks/thread-ops.js

@@ -0,0 +1,2 @@
+export * from './thread-forum-ops.js';
+export * from './thread-lifecycle-ops.js';

package/dist/tasks/types.js

@@ -0,0 +1,20 @@
+// ---------------------------------------------------------------------------
+// Task store types — in-process task data model.
+// Replaces the external `bd` CLI dependency for the read/write path.
+// ---------------------------------------------------------------------------
+export const TASK_STATUSES = [
+    'open',
+    'in_progress',
+    'blocked',
+    'closed',
+];
+export function isTaskStatus(s) {
+    return TASK_STATUSES.includes(s);
+}
+/** Status → emoji prefix for thread names. Widened to Record<string, string> for consumers that index with a plain string. */
+export const STATUS_EMOJI = {
+    open: '\u{1F7E2}', // 🟢
+    in_progress: '\u{1F7E1}', // 🟡
+    blocked: '\u26A0\uFE0F', // ⚠️
+    closed: '\u2611\uFE0F', // ☑️
+};

package/dist/tasks/types.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { TASK_STATUSES, isTaskStatus, STATUS_EMOJI, } from './types.js';
+describe('Task types', () => {
+    it('isTaskStatus accepts valid statuses', () => {
+        expect(isTaskStatus('open')).toBe(true);
+        expect(isTaskStatus('in_progress')).toBe(true);
+        expect(isTaskStatus('blocked')).toBe(true);
+        expect(isTaskStatus('closed')).toBe(true);
+    });
+    it('isTaskStatus rejects invalid statuses', () => {
+        expect(isTaskStatus('unknown')).toBe(false);
+        expect(isTaskStatus('')).toBe(false);
+    });
+    it('STATUS_EMOJI is indexable with a plain string', () => {
+        const status = 'open';
+        // This must compile and return a value (widened type check)
+        expect(STATUS_EMOJI[status]).toBe('\u{1F7E2}');
+    });
+    it('STATUS_EMOJI covers all TASK_STATUSES', () => {
+        for (const s of TASK_STATUSES) {
+            expect(STATUS_EMOJI[s]).toBeDefined();
+        }
+    });
+    // Type-level assertions for canonical task types.
+    // These are compile-time checks; if they compile the test passes at runtime.
+    it('Task types are assignable in expected shapes', () => {
+        const taskData = {
+            id: '1',
+            title: 'test',
+            status: 'open',
+        };
+        const taskData2 = taskData;
+        expect(taskData2).toBe(taskData);
+        const taskStatus = 'open';
+        expect(taskStatus).toBe('open');
+        const syncResult = {
+            threadsCreated: 0,
+            emojisUpdated: 0,
+            starterMessagesUpdated: 0,
+            threadsArchived: 0,
+            statusesUpdated: 0,
+            tagsUpdated: 0,
+            warnings: 0,
+        };
+        const syncResult2 = syncResult;
+        expect(syncResult2).toBe(syncResult);
+        const createParams = { title: 'x' };
+        const createParams2 = createParams;
+        expect(createParams2).toBe(createParams);
+        const updateParams = { title: 'y' };
+        const updateParams2 = updateParams;
+        expect(updateParams2).toBe(updateParams);
+        const closeParams = { reason: 'done' };
+        const closeParams2 = closeParams;
+        expect(closeParams2).toBe(closeParams);
+        const listParams = { status: 'open' };
+        const listParams2 = listParams;
+        expect(listParams2).toBe(listParams);
+    });
+});

package/dist/test-setup.js

@@ -0,0 +1,11 @@
+import { afterEach, vi } from 'vitest';
+// After each test: clear accumulated mock call/result history to prevent
+// monotonic memory growth across tests within a worker.
+afterEach(() => {
+    vi.clearAllMocks();
+    vi.unstubAllEnvs();
+    vi.unstubAllGlobals();
+    // Safety net: restore real timers if a test used vi.useFakeTimers() but
+    // failed or threw before its own cleanup ran.
+    vi.useRealTimers();
+});

package/dist/test-setup.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it, vi } from 'vitest';
+// Verify that the global afterEach hooks registered in test-setup.ts
+// actually clear mock state and env stubs between tests.
+// Shared spy — persists across it() blocks within this describe so the second
+// test can confirm the first test's call history was cleared by afterEach.
+const sharedSpy = vi.fn();
+describe('test-setup global afterEach hooks', () => {
+    describe('vi.clearAllMocks', () => {
+        it('populates shared spy call history in this test', () => {
+            sharedSpy('arg1');
+            sharedSpy('arg2');
+            expect(sharedSpy.mock.calls).toHaveLength(2);
+            // afterEach will call vi.clearAllMocks() — verified by the next test.
+        });
+        it('shared spy call history is empty after the previous test ran afterEach', () => {
+            // sharedSpy was called twice above; if clearAllMocks ran between tests
+            // its call history must now be empty.
+            expect(sharedSpy.mock.calls).toHaveLength(0);
+        });
+    });
+    describe('vi.unstubAllEnvs', () => {
+        it('stubs an env var in this test', () => {
+            vi.stubEnv('TEST_SETUP_SENTINEL', 'stubbed');
+            expect(process.env['TEST_SETUP_SENTINEL']).toBe('stubbed');
+            // afterEach will call vi.unstubAllEnvs().
+        });
+        it('env stub is restored after the previous test ran afterEach', () => {
+            expect(process.env['TEST_SETUP_SENTINEL']).toBeUndefined();
+        });
+    });
+    describe('vi.useRealTimers', () => {
+        it('installs fake timers in this test', () => {
+            vi.useFakeTimers();
+            // Confirm fake timers are active: setTimeout should be the vitest stub.
+            expect(vi.isFakeTimers()).toBe(true);
+            // afterEach will call vi.useRealTimers() as a safety net.
+        });
+        it('real timers are restored after the previous test ran afterEach', () => {
+            expect(vi.isFakeTimers()).toBe(false);
+        });
+    });
+});

package/dist/transport/types.js

@@ -0,0 +1 @@
+export {};

package/dist/validate.js

@@ -0,0 +1,41 @@
+/**
+ * Shared validators for Discord tokens and snowflake IDs.
+ * Used by scripts/doctor.ts and scripts/setup.ts.
+ */
+/** Token: 3 dot-separated base64url segments. */
+export function validateDiscordToken(token) {
+    if (!token)
+        return { valid: false, reason: 'Token is empty' };
+    const parts = token.split('.');
+    if (parts.length !== 3) {
+        return { valid: false, reason: `Expected 3 dot-separated segments, got ${parts.length}` };
+    }
+    // Each segment must be non-empty base64url (A-Z, a-z, 0-9, -, _)
+    const base64url = /^[A-Za-z0-9\-_]+$/;
+    for (let i = 0; i < parts.length; i++) {
+        if (!parts[i] || !base64url.test(parts[i])) {
+            return { valid: false, reason: `Segment ${i + 1} contains invalid characters` };
+        }
+    }
+    return { valid: true };
+}
+/**
+ * Snowflake: 17-20 digit numeric string.
+ *
+ * This is intentionally stricter than the runtime `isSnowflake()` in
+ * system-bootstrap.ts (which accepts 8+ digits for historical reasons).
+ * Real Discord snowflakes are always 17-20 digits. This stricter check
+ * is used in user-facing tools (doctor, setup wizard) to catch mistyped
+ * IDs early. Runtime code keeps the looser pattern for compatibility.
+ */
+export function validateSnowflake(id) {
+    return /^\d{17,20}$/.test(id);
+}
+/** Comma/space-separated snowflake list. Returns invalid IDs if any. */
+export function validateSnowflakes(raw) {
+    const ids = raw.split(/[,\s]+/).filter(Boolean);
+    if (ids.length === 0)
+        return { valid: false, invalidIds: [] };
+    const invalidIds = ids.filter((id) => !validateSnowflake(id));
+    return { valid: invalidIds.length === 0, invalidIds };
+}

package/dist/validate.test.js

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+import { validateDiscordToken, validateSnowflake, validateSnowflakes } from './validate.js';
+describe('validateDiscordToken', () => {
+    it('accepts a valid 3-segment base64url token', () => {
+        expect(validateDiscordToken('MTIzNDU2Nzg5.abc123.def456-_')).toEqual({ valid: true });
+    });
+    it('rejects empty string', () => {
+        const r = validateDiscordToken('');
+        expect(r.valid).toBe(false);
+        expect(r.reason).toMatch(/empty/i);
+    });
+    it('rejects token with wrong segment count (2 segments)', () => {
+        const r = validateDiscordToken('abc.def');
+        expect(r.valid).toBe(false);
+        expect(r.reason).toMatch(/3 dot-separated/);
+    });
+    it('rejects token with wrong segment count (4 segments)', () => {
+        const r = validateDiscordToken('a.b.c.d');
+        expect(r.valid).toBe(false);
+        expect(r.reason).toMatch(/3 dot-separated/);
+    });
+    it('rejects token with no dots', () => {
+        const r = validateDiscordToken('nodots');
+        expect(r.valid).toBe(false);
+        expect(r.reason).toMatch(/1$/);
+    });
+    it('rejects token with invalid base64 chars', () => {
+        const r = validateDiscordToken('abc.d e f.ghi');
+        expect(r.valid).toBe(false);
+        expect(r.reason).toMatch(/invalid characters/);
+    });
+    it('rejects token with empty segment', () => {
+        const r = validateDiscordToken('abc..ghi');
+        expect(r.valid).toBe(false);
+        expect(r.reason).toMatch(/invalid characters/);
+    });
+    it('accepts token with hyphens and underscores (base64url)', () => {
+        expect(validateDiscordToken('a-b.c_d.e-f')).toEqual({ valid: true });
+    });
+});
+describe('validateSnowflake', () => {
+    it('accepts 17-digit snowflake', () => {
+        expect(validateSnowflake('12345678901234567')).toBe(true);
+    });
+    it('accepts 18-digit snowflake', () => {
+        expect(validateSnowflake('123456789012345678')).toBe(true);
+    });
+    it('accepts 19-digit snowflake', () => {
+        expect(validateSnowflake('1234567890123456789')).toBe(true);
+    });
+    it('accepts 20-digit snowflake', () => {
+        expect(validateSnowflake('12345678901234567890')).toBe(true);
+    });
+    it('rejects 16-digit string (too short)', () => {
+        expect(validateSnowflake('1234567890123456')).toBe(false);
+    });
+    it('rejects 21-digit string (too long)', () => {
+        expect(validateSnowflake('123456789012345678901')).toBe(false);
+    });
+    it('rejects string with letters', () => {
+        expect(validateSnowflake('1234567890123456a')).toBe(false);
+    });
+    it('rejects empty string', () => {
+        expect(validateSnowflake('')).toBe(false);
+    });
+    it('rejects string with spaces', () => {
+        expect(validateSnowflake('1234567890 1234567')).toBe(false);
+    });
+});
+describe('validateSnowflakes', () => {
+    it('validates a single valid snowflake', () => {
+        expect(validateSnowflakes('12345678901234567')).toEqual({ valid: true, invalidIds: [] });
+    });
+    it('validates comma-separated snowflakes', () => {
+        expect(validateSnowflakes('12345678901234567,98765432109876543')).toEqual({ valid: true, invalidIds: [] });
+    });
+    it('validates space-separated snowflakes', () => {
+        expect(validateSnowflakes('12345678901234567 98765432109876543')).toEqual({ valid: true, invalidIds: [] });
+    });
+    it('validates mixed comma and space separation', () => {
+        expect(validateSnowflakes('12345678901234567, 98765432109876543')).toEqual({ valid: true, invalidIds: [] });
+    });
+    it('returns invalid IDs in a mixed list', () => {
+        const r = validateSnowflakes('12345678901234567,abc,98765432109876543,short');
+        expect(r.valid).toBe(false);
+        expect(r.invalidIds).toEqual(['abc', 'short']);
+    });
+    it('returns invalid when empty string is given', () => {
+        expect(validateSnowflakes('')).toEqual({ valid: false, invalidIds: [] });
+    });
+    it('returns invalid when only whitespace/commas', () => {
+        expect(validateSnowflakes(', , ')).toEqual({ valid: false, invalidIds: [] });
+    });
+});

package/dist/version.js

@@ -0,0 +1,15 @@
+import { execa } from 'execa';
+/**
+ * Returns the short git commit hash of the current HEAD, or null if git is
+ * unavailable or the working directory is not a git repository.
+ */
+export async function getGitHash() {
+    try {
+        const result = await execa('git', ['rev-parse', '--short', 'HEAD']);
+        const hash = result.stdout.trim();
+        return hash || null;
+    }
+    catch {
+        return null;
+    }
+}