discoclaw 1.3.0 → 2.0.0

package/dist/tasks/task-action-executor.test.js

@@ -50,11 +50,11 @@ vi.mock('./task-sync-engine.js', () => {
 // ---------------------------------------------------------------------------
 function makeCtx() {
     return {
-        guild: {},
+        guild: { id: 'guild-current' },
         client: {
             channels: {
                 cache: {
-                    get: () => undefined,
+                    get: vi.fn(() => undefined),
                 },
             },
         },
@@ -62,8 +62,8 @@ function makeCtx() {
         messageId: 'msg-current',
     };
 }
-function makeStore() {
-    const defaultTask = (id) => ({
+function makeTask(id, overrides = {}) {
+    return {
         id,
         title: 'Test task',
         description: 'A test',
@@ -76,34 +76,81 @@ function makeStore() {
         comments: [],
         created_at: '2026-01-01T00:00:00Z',
         updated_at: '2026-01-01T00:00:00Z',
-    });
+        ...overrides,
+    };
+}
+function makeStore(opts) {
+    const tasks = new Map((opts?.initialTasks ?? [
+        makeTask('ws-001', { title: 'First' }),
+        makeTask('ws-002', {
+            title: 'Second',
+            status: 'in_progress',
+            priority: 1,
+            external_ref: 'discord:222333444',
+            labels: [],
+        }),
+    ]).map((task) => [task.id, task]));
     return {
-        get: vi.fn((id) => {
-            if (id === 'ws-notfound')
-                return undefined;
-            return defaultTask(id);
+        get: vi.fn((id) => tasks.get(id)),
+        list: vi.fn((params) => (Array.from(tasks.values()).slice(0, params?.limit ?? 50))),
+        create: vi.fn((params) => {
+            const createTaskOverrides = typeof opts?.createTaskOverrides === 'function'
+                ? opts.createTaskOverrides(params)
+                : (opts?.createTaskOverrides ?? {});
+            const task = makeTask('ws-new', {
+                title: params.title,
+                description: params.description ?? '',
+                priority: params.priority ?? 2,
+                external_ref: '',
+                labels: params.labels ?? [],
+                ...createTaskOverrides,
+            });
+            tasks.set(task.id, task);
+            return task;
+        }),
+        update: vi.fn((id, params) => {
+            const prev = tasks.get(id);
+            if (!prev)
+                throw new Error(`task not found: ${id}`);
+            const updated = makeTask(id, {
+                ...prev,
+                ...(params.title !== undefined ? { title: params.title } : {}),
+                ...(params.description !== undefined ? { description: params.description } : {}),
+                ...(params.priority !== undefined ? { priority: params.priority } : {}),
+                ...(params.status !== undefined ? { status: params.status } : {}),
+                ...(params.owner !== undefined ? { owner: params.owner } : {}),
+                ...(params.externalRef !== undefined ? { external_ref: params.externalRef } : {}),
+                ...(params.threadOriginGuild !== undefined ? { thread_origin_guild: params.threadOriginGuild } : {}),
+                updated_at: '2026-01-02T00:00:00Z',
+            });
+            tasks.set(id, updated);
+            return updated;
+        }),
+        close: vi.fn((id) => {
+            const prev = tasks.get(id);
+            if (!prev)
+                throw new Error(`task not found: ${id}`);
+            const updated = makeTask(id, {
+                ...prev,
+                status: 'closed',
+                closed_at: '2026-01-02T00:00:00Z',
+                updated_at: '2026-01-02T00:00:00Z',
+            });
+            tasks.set(id, updated);
+            return updated;
+        }),
+        addLabel: vi.fn((id, label) => {
+            const prev = tasks.get(id);
+            if (!prev)
+                throw new Error(`task not found: ${id}`);
+            const updated = makeTask(id, {
+                ...prev,
+                labels: [...new Set([...(prev.labels ?? []), label])],
+                updated_at: '2026-01-02T00:00:00Z',
+            });
+            tasks.set(id, updated);
+            return updated;
         }),
-        list: vi.fn(() => [
-            { id: 'ws-001', title: 'First', status: 'open', priority: 2 },
-            { id: 'ws-002', title: 'Second', status: 'in_progress', priority: 1 },
-        ]),
-        create: vi.fn((params) => ({
-            id: 'ws-new',
-            title: params.title,
-            description: params.description ?? '',
-            status: 'open',
-            priority: params.priority ?? 2,
-            issue_type: 'task',
-            owner: '',
-            external_ref: '',
-            labels: params.labels ?? [],
-            comments: [],
-            created_at: '2026-01-01T00:00:00Z',
-            updated_at: '2026-01-01T00:00:00Z',
-        })),
-        update: vi.fn((id) => defaultTask(id)),
-        close: vi.fn((id) => ({ ...defaultTask(id), status: 'closed' })),
-        addLabel: vi.fn((id) => defaultTask(id)),
         reload: vi.fn(async () => ({ added: [], updated: [], removed: [] })),
     };
 }
@@ -137,11 +184,19 @@ describe('TASK_ACTION_TYPES', () => {
     });
 });
 describe('executeTaskAction', () => {
-    it('taskCreate returns created task summary', async () => {
+    it('taskCreate returns a real Discord thread URL and structured thread metadata', async () => {
         const result = await executeTaskAction({ type: 'taskCreate', title: 'New task', priority: 1 }, makeCtx(), makeTaskCtx());
+        const success = result;
         expect(result.ok).toBe(true);
-        expect(result.summary).toContain('ws-new');
-        expect(result.summary).toContain('New task');
+        expect(success.summary).toContain('ws-new');
+        expect(success.summary).toContain('New task');
+        expect(success.summary).toContain('Thread: https://discord.com/channels/guild-current/thread-new');
+        expect(success.thread).toEqual({
+            externalRef: 'discord:thread-new',
+            threadId: 'thread-new',
+            threadGuildId: 'guild-current',
+            threadUrl: 'https://discord.com/channels/guild-current/thread-new',
+        });
     });
     it('taskCreate calls forumCountSync.requestUpdate', async () => {
         const mockSync = { requestUpdate: vi.fn(), stop: vi.fn() };
@@ -157,28 +212,29 @@ describe('executeTaskAction', () => {
         createTaskThread.mockClear?.();
         const result = await executeTaskAction({ type: 'taskCreate', title: 'No thread please', tags: 'no-thread,feature' }, makeCtx(), makeTaskCtx());
         expect(result.ok).toBe(true);
+        expect(result.summary).not.toContain('Thread:');
+        expect(result.thread).toBeUndefined();
         expect(createTaskThread).not.toHaveBeenCalled();
     });
-    it('taskCreate skips thread creation when task is already linked before direct lifecycle step', async () => {
+    it('taskCreate backfills missing origin guild data for already-linked tasks', async () => {
         const { createTaskThread } = await import('./thread-ops.js');
         createTaskThread.mockClear?.();
-        const store = makeStore();
-        store.get.mockImplementation((id) => ({
-            id,
-            title: 'Already linked',
-            status: 'open',
-            priority: 2,
-            issue_type: 'task',
-            owner: '',
-            external_ref: 'discord:thread-existing',
-            labels: ['feature'],
-            comments: [],
-            created_at: '2026-01-01T00:00:00Z',
-            updated_at: '2026-01-01T00:00:00Z',
-        }));
+        const store = makeStore({
+            createTaskOverrides: {
+                title: 'Already linked',
+                external_ref: 'discord:thread-existing',
+            },
+        });
         const result = await executeTaskAction({ type: 'taskCreate', title: 'Task already linked' }, makeCtx(), makeTaskCtx({ store: store }));
         expect(result.ok).toBe(true);
-        expect(result.summary).toContain('thread linked');
+        expect(result.summary).toContain('Thread: https://discord.com/channels/guild-current/thread-existing');
+        expect(result.thread).toEqual({
+            externalRef: 'discord:thread-existing',
+            threadId: 'thread-existing',
+            threadGuildId: 'guild-current',
+            threadUrl: 'https://discord.com/channels/guild-current/thread-existing',
+        });
+        expect(store.update).toHaveBeenCalledWith('ws-new', { threadOriginGuild: 'guild-current' });
         expect(createTaskThread).not.toHaveBeenCalled();
     });
     it('taskUpdate returns updated summary', async () => {
@@ -301,9 +357,65 @@ describe('executeTaskAction', () => {
     it('taskShow returns task details', async () => {
         const result = await executeTaskAction({ type: 'taskShow', taskId: 'ws-001' }, makeCtx(), makeTaskCtx());
         expect(result.ok).toBe(true);
-        expect(result.summary).toContain('Test task');
+        expect(result.summary).toContain('First');
         expect(result.summary).toContain('ws-001');
     });
+    it('taskShow shows External ref for linked tasks even without canonical thread URL data', async () => {
+        const store = makeStore({
+            initialTasks: [
+                makeTask('ws-001', {
+                    title: 'Linked elsewhere',
+                    external_ref: 'gh:123',
+                    thread_origin_guild: undefined,
+                }),
+            ],
+        });
+        const result = await executeTaskAction({ type: 'taskShow', taskId: 'ws-001' }, makeCtx(), makeTaskCtx({ store: store }));
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('External ref: gh:123');
+        expect(result.summary).not.toContain('Thread:');
+        expect(result.thread).toEqual({ externalRef: 'gh:123' });
+    });
+    it('taskShow only emits Thread when stored origin guild data exists', async () => {
+        const store = makeStore({
+            initialTasks: [
+                makeTask('ws-001', {
+                    title: 'Thread-linked',
+                    external_ref: 'discord:111222333',
+                    thread_origin_guild: 'guild-stored',
+                }),
+            ],
+        });
+        const result = await executeTaskAction({ type: 'taskShow', taskId: 'ws-001' }, makeCtx(), makeTaskCtx({ store: store }));
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('External ref: discord:111222333');
+        expect(result.summary).toContain('Thread: https://discord.com/channels/guild-stored/111222333');
+        expect(result.thread).toEqual({
+            externalRef: 'discord:111222333',
+            threadId: '111222333',
+            threadGuildId: 'guild-stored',
+            threadUrl: 'https://discord.com/channels/guild-stored/111222333',
+        });
+    });
+    it('taskShow does not perform live Discord lookups', async () => {
+        const { resolveTasksForum } = await import('./thread-ops.js');
+        resolveTasksForum.mockClear?.();
+        const ctx = makeCtx();
+        const cacheGet = ctx.client.channels.cache.get;
+        const result = await executeTaskAction({ type: 'taskShow', taskId: 'ws-001' }, ctx, makeTaskCtx({
+            store: makeStore({
+                initialTasks: [
+                    makeTask('ws-001', {
+                        external_ref: 'discord:111222333',
+                        thread_origin_guild: 'guild-stored',
+                    }),
+                ],
+            }),
+        }));
+        expect(result.ok).toBe(true);
+        expect(resolveTasksForum).not.toHaveBeenCalled();
+        expect(cacheGet).not.toHaveBeenCalled();
+    });
     it('taskShow fails for unknown task', async () => {
         const result = await executeTaskAction({ type: 'taskShow', taskId: 'ws-notfound' }, makeCtx(), makeTaskCtx());
         expect(result.ok).toBe(false);

package/dist/tasks/task-action-mutations.js

@@ -4,6 +4,7 @@ import { autoTagTask } from './auto-tag.js';
 import { taskThreadCache } from './thread-cache.js';
 import { resolveTaskId, resolveTaskService, scheduleRepairSync, } from './task-action-mutation-helpers.js';
 import { ensureCreatedTaskThreadLink, syncClosedTaskThread, syncUpdatedTaskThread, } from './task-action-thread-sync.js';
+import { getTaskActionThreadMetadata } from './task-action-runner-types.js';
 /** Pre-computed set for filtering status names from tag candidates. */
 const STATUS_NAME_SET = new Set(TASK_STATUSES);
 /**
@@ -73,10 +74,29 @@ export async function handleTaskCreate(action, ctx, taskCtx) {
     if (needsRepairSync) {
         scheduleRepairSync(taskCtx, task.id, ctx);
     }
+    let linkedTask = taskCtx.store.get(task.id) ?? task;
+    const storedThread = getTaskActionThreadMetadata(linkedTask);
+    const linkedThreadId = storedThread?.threadId ?? (threadId || undefined);
+    const guildId = ctx.guild.id?.trim() || undefined;
+    if (linkedThreadId && guildId && !linkedTask.thread_origin_guild) {
+        try {
+            linkedTask = taskService.update(task.id, {
+                ...(storedThread ? {} : { externalRef: `discord:${linkedThreadId}` }),
+                threadOriginGuild: guildId,
+            });
+        }
+        catch (err) {
+            taskCtx.log?.warn({ err, taskId: task.id, threadId: linkedThreadId, guildId }, 'tasks:thread origin guild update failed');
+        }
+    }
+    const thread = getTaskActionThreadMetadata(linkedTask);
     taskThreadCache.invalidate();
     taskCtx.forumCountSync?.requestUpdate();
-    const threadNote = threadId ? ' (thread linked)' : '';
-    return { ok: true, summary: `Task ${task.id} created: "${task.title}"${threadNote}` };
+    const summary = [
+        `Task ${task.id} created: "${task.title}"`,
+        ...(thread?.threadUrl ? [`Thread: ${thread.threadUrl}`] : []),
+    ].join('\n');
+    return { ok: true, summary, ...(thread ? { thread } : {}) };
 }
 export async function handleTaskUpdate(action, ctx, taskCtx) {
     const taskId = resolveTaskId(action);

package/dist/tasks/task-action-read-ops.js

@@ -1,5 +1,6 @@
 import { runTaskSync } from './task-sync.js';
 import { reloadTagMapInPlace } from './tag-map.js';
+import { getTaskActionThreadMetadata } from './task-action-runner-types.js';
 function resolveTaskId(action) {
     return (action.taskId ?? '').trim();
 }
@@ -18,11 +19,16 @@ export async function handleTaskShow(action, _ctx, taskCtx) {
     ];
     if (task.owner)
         lines.push(`Owner: ${task.owner}`);
+    const thread = getTaskActionThreadMetadata(task);
+    if (thread)
+        lines.push(`External ref: ${thread.externalRef}`);
+    if (thread?.threadUrl)
+        lines.push(`Thread: ${thread.threadUrl}`);
     if (task.labels?.length)
         lines.push(`Labels: ${task.labels.join(', ')}`);
     if (task.description)
         lines.push(`\n${task.description.slice(0, 500)}`);
-    return { ok: true, summary: lines.join('\n') };
+    return { ok: true, summary: lines.join('\n'), ...(thread ? { thread } : {}) };
 }
 export async function handleTaskList(action, _ctx, taskCtx) {
     const tasks = taskCtx.store.list({

package/dist/tasks/task-action-runner-types.js

@@ -1 +1,19 @@
-export {};
+import { getThreadIdFromTask } from './thread-helpers.js';
+export function buildDiscordThreadUrl(guildId, threadId) {
+    return `https://discord.com/channels/${guildId}/${threadId}`;
+}
+export function getTaskActionThreadMetadata(task) {
+    const externalRef = task.external_ref?.trim() ?? '';
+    if (!externalRef)
+        return undefined;
+    const threadId = getThreadIdFromTask(task) ?? undefined;
+    const threadGuildId = task.thread_origin_guild?.trim() || undefined;
+    return {
+        externalRef,
+        ...(threadId ? { threadId } : {}),
+        ...(threadGuildId ? { threadGuildId } : {}),
+        ...(threadId && threadGuildId
+            ? { threadUrl: buildDiscordThreadUrl(threadGuildId, threadId) }
+            : {}),
+    };
+}