discoclaw 0.1.0

package/dist/discord/actions-defer.test.js

@@ -0,0 +1,134 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { DeferScheduler } from './defer-scheduler.js';
+import { executeDeferAction } from './actions-defer.js';
+const baseContext = {
+    guild: { id: 'guild-1' },
+    client: { token: 'dummy' },
+    channelId: 'channel-1',
+    messageId: 'message-1',
+};
+afterEach(() => {
+    vi.useRealTimers();
+});
+function createContext(overrides) {
+    return {
+        ...baseContext,
+        ...overrides,
+    };
+}
+function makeScheduler(opts) {
+    const handler = opts?.jobHandler ?? vi.fn(async () => { });
+    const scheduler = new DeferScheduler({
+        maxDelaySeconds: opts?.maxDelaySeconds ?? 60,
+        maxConcurrent: opts?.maxConcurrent ?? 2,
+        jobHandler: handler,
+    });
+    return { scheduler, handler };
+}
+describe('executeDeferAction', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-01-01T00:00:00Z'));
+    });
+    it('requires scheduler configuration', async () => {
+        const result = await executeDeferAction({ type: 'defer', channel: 'general', prompt: 'check', delaySeconds: 10 }, baseContext);
+        expect(result.ok).toBe(false);
+        if (result.ok)
+            throw new Error('defer action unexpectedly succeeded without a scheduler');
+        expect(result.error).toContain('not configured');
+    });
+    it('validates input fields', async () => {
+        const { scheduler } = makeScheduler();
+        const ctx = {
+            ...createContext(),
+            deferScheduler: scheduler,
+        };
+        await expect(executeDeferAction({ type: 'defer', channel: '', prompt: 'check', delaySeconds: 1 }, ctx)).resolves.toEqual(expect.objectContaining({ ok: false, error: expect.stringContaining('target channel') }));
+        await expect(executeDeferAction({ type: 'defer', channel: 'a', prompt: '', delaySeconds: 1 }, ctx)).resolves.toEqual(expect.objectContaining({ ok: false, error: expect.stringContaining('prompt') }));
+        await expect(executeDeferAction({ type: 'defer', channel: 'a', prompt: 'x', delaySeconds: 0 }, ctx)).resolves.toEqual(expect.objectContaining({ ok: false, error: expect.stringContaining('greater than zero') }));
+    });
+    it('schedules deferred run when valid', async () => {
+        const { scheduler, handler } = makeScheduler();
+        const ctx = {
+            ...createContext(),
+            deferScheduler: scheduler,
+        };
+        const action = { type: 'defer', channel: 'general', prompt: 'report', delaySeconds: 5 };
+        const result = await executeDeferAction(action, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            throw new Error('defer action failed when it should have succeeded');
+        expect(result.summary).toContain('general');
+        expect(result.summary).toContain('in 5s');
+        expect(result.summary).toContain('runs at 2025-01-01');
+        vi.advanceTimersByTime(5000);
+        await Promise.resolve();
+        expect(handler).toHaveBeenCalledTimes(1);
+        expect(handler).toHaveBeenCalledWith(expect.objectContaining({
+            action: expect.objectContaining({
+                channel: 'general',
+                prompt: 'report',
+                delaySeconds: 5,
+            }),
+            context: ctx,
+        }));
+    });
+    it('returns rejection summaries when scheduler denies a job', async () => {
+        const { scheduler } = makeScheduler({ maxDelaySeconds: 5 });
+        const ctx = {
+            ...createContext(),
+            deferScheduler: scheduler,
+        };
+        const action = { type: 'defer', channel: 'general', prompt: 'check back', delaySeconds: 10 };
+        const result = await executeDeferAction(action, ctx);
+        expect(result.ok).toBe(false);
+        if (result.ok)
+            throw new Error('defer action unexpectedly succeeded despite exceeding max delay');
+        expect(result.error).toBe('Deferred follow-up for general rejected: delaySeconds cannot exceed 5 seconds');
+    });
+});
+describe('DeferScheduler', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    it('enforces max delay', () => {
+        const { scheduler } = makeScheduler({ maxDelaySeconds: 5 });
+        const ctx = createContext();
+        const action = { type: 'defer', channel: 'a', prompt: 'x', delaySeconds: 10 };
+        const result = scheduler.schedule({ action, context: ctx });
+        expect(result.ok).toBe(false);
+        if (result.ok)
+            throw new Error('schedule unexpectedly succeeded despite exceeding max delay');
+        expect(result.error).toMatch(/delaySeconds cannot exceed 5/);
+    });
+    it('enforces concurrency cap', () => {
+        const { scheduler } = makeScheduler({ maxConcurrent: 1 });
+        const ctx = {
+            ...createContext(),
+            deferScheduler: scheduler,
+        };
+        const action = { type: 'defer', channel: 'a', prompt: 'x', delaySeconds: 2 };
+        const first = scheduler.schedule({ action, context: ctx });
+        expect(first.ok).toBe(true);
+        const second = scheduler.schedule({ action: { ...action, channel: 'b' }, context: ctx });
+        expect(second.ok).toBe(false);
+        if (second.ok)
+            throw new Error('schedule unexpectedly succeeded despite concurrency cap');
+        expect(second.error).toMatch(/Maximum of 1 deferred actions/);
+        vi.advanceTimersByTime(2000);
+    });
+    it('releases slot after run completes', async () => {
+        const { scheduler } = makeScheduler({ maxConcurrent: 1 });
+        const ctx = {
+            ...createContext(),
+            deferScheduler: scheduler,
+        };
+        const action = { type: 'defer', channel: 'a', prompt: 'x', delaySeconds: 1 };
+        const first = scheduler.schedule({ action, context: ctx });
+        expect(first.ok).toBe(true);
+        vi.advanceTimersByTime(1000);
+        await Promise.resolve();
+        const second = scheduler.schedule({ action: { ...action, channel: 'b' }, context: ctx });
+        expect(second.ok).toBe(true);
+    });
+});

package/dist/discord/actions-forge.js

@@ -0,0 +1,134 @@
+import { findPlanFile } from './plan-commands.js';
+import { getActiveOrchestrator, getActiveForgeId, acquireWriterLock, setActiveOrchestrator, } from './forge-plan-registry.js';
+const FORGE_TYPE_MAP = {
+    forgeCreate: true,
+    forgeResume: true,
+    forgeStatus: true,
+    forgeCancel: true,
+};
+export const FORGE_ACTION_TYPES = new Set(Object.keys(FORGE_TYPE_MAP));
+// ---------------------------------------------------------------------------
+// Executor
+// ---------------------------------------------------------------------------
+export async function executeForgeAction(action, ctx, forgeCtx) {
+    switch (action.type) {
+        case 'forgeCreate': {
+            if ((forgeCtx.depth ?? 0) >= 1) {
+                return { ok: false, error: 'forgeCreate blocked: recursion depth >= 1 (forge cannot spawn another forge)' };
+            }
+            if (!action.description) {
+                return { ok: false, error: 'forgeCreate requires a description' };
+            }
+            const existing = getActiveOrchestrator();
+            if (existing?.isRunning) {
+                const activeId = getActiveForgeId();
+                return {
+                    ok: false,
+                    error: `A forge is already running${activeId ? ` (${activeId})` : ''}. Cancel it first with forgeCancel.`,
+                };
+            }
+            const orchestrator = forgeCtx.orchestratorFactory();
+            setActiveOrchestrator(orchestrator);
+            // Fire and forget — forge runs asynchronously with progress callbacks.
+            const release = await acquireWriterLock();
+            void orchestrator
+                .run(action.description, forgeCtx.onProgress, action.context)
+                .catch((err) => {
+                forgeCtx.log?.error({ err }, 'forge:action:create failed');
+            })
+                .finally(() => {
+                setActiveOrchestrator(null);
+                release();
+            });
+            return { ok: true, summary: `Forge started for: "${action.description}"` };
+        }
+        case 'forgeResume': {
+            if ((forgeCtx.depth ?? 0) >= 1) {
+                return { ok: false, error: 'forgeResume blocked: recursion depth >= 1 (forge cannot spawn another forge)' };
+            }
+            if (!action.planId) {
+                return { ok: false, error: 'forgeResume requires a planId' };
+            }
+            const existing = getActiveOrchestrator();
+            if (existing?.isRunning) {
+                const activeId = getActiveForgeId();
+                return {
+                    ok: false,
+                    error: `A forge is already running${activeId ? ` (${activeId})` : ''}. Cancel it first with forgeCancel.`,
+                };
+            }
+            const planOpts = {
+                workspaceCwd: forgeCtx.workspaceCwd,
+                taskStore: forgeCtx.taskStore,
+            };
+            const found = await findPlanFile(forgeCtx.plansDir, action.planId);
+            if (!found) {
+                return { ok: false, error: `Plan not found: ${action.planId}` };
+            }
+            const orchestrator = forgeCtx.orchestratorFactory();
+            setActiveOrchestrator(orchestrator);
+            const release = await acquireWriterLock();
+            void orchestrator
+                .resume(found.header.planId, found.filePath, found.header.title, forgeCtx.onProgress)
+                .catch((err) => {
+                forgeCtx.log?.error({ err, planId: action.planId }, 'forge:action:resume failed');
+            })
+                .finally(() => {
+                setActiveOrchestrator(null);
+                release();
+            });
+            return { ok: true, summary: `Forge resumed for ${found.header.planId}: "${found.header.title}"` };
+        }
+        case 'forgeStatus': {
+            const orch = getActiveOrchestrator();
+            if (orch?.isRunning) {
+                const activeId = getActiveForgeId();
+                return { ok: true, summary: `Forge is running${activeId ? `: ${activeId}` : ''}` };
+            }
+            return { ok: true, summary: 'No forge is currently running.' };
+        }
+        case 'forgeCancel': {
+            const orch = getActiveOrchestrator();
+            if (!orch?.isRunning) {
+                return { ok: false, error: 'No forge is currently running.' };
+            }
+            orch.requestCancel();
+            const activeId = getActiveForgeId();
+            return { ok: true, summary: `Cancel requested${activeId ? ` for ${activeId}` : ''}` };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Prompt section
+// ---------------------------------------------------------------------------
+export function forgeActionsPromptSection() {
+    return `### Forge (Plan Drafting + Audit)
+
+**forgeCreate** — Start a new forge run (drafts a plan, then audits/revises iteratively):
+\`\`\`
+<discord-action>{"type":"forgeCreate","description":"Add retry logic to webhook handler","context":"Optional extra context or requirements"}</discord-action>
+\`\`\`
+- \`description\` (required): What to plan for.
+- \`context\` (optional): Additional context appended to the plan.
+
+**forgeResume** — Resume auditing an existing plan (re-enters the audit/revise loop):
+\`\`\`
+<discord-action>{"type":"forgeResume","planId":"plan-042"}</discord-action>
+\`\`\`
+- \`planId\` (required): The plan ID to resume.
+
+**forgeStatus** — Check if a forge is currently running:
+\`\`\`
+<discord-action>{"type":"forgeStatus"}</discord-action>
+\`\`\`
+
+**forgeCancel** — Cancel a running forge:
+\`\`\`
+<discord-action>{"type":"forgeCancel"}</discord-action>
+\`\`\`
+
+#### Forge Guidelines
+- Only one forge can run at a time. Check status before starting a new one.
+- Forge runs are asynchronous — progress updates are posted to the channel.
+- Use forgeResume to re-audit a plan that needs another pass (e.g., after manual edits).`;
+}

package/dist/discord/actions-forge.test.js

@@ -0,0 +1,206 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { FORGE_ACTION_TYPES, executeForgeAction, forgeActionsPromptSection } from './actions-forge.js';
+import { _resetForTest, setActiveOrchestrator } from './forge-plan-registry.js';
+import { TaskStore } from '../tasks/store.js';
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+vi.mock('./plan-commands.js', () => ({
+    looksLikePlanId: vi.fn((id) => /^\d+$/.test(id) || /^plan-\d+$/.test(id)),
+    findPlanFile: vi.fn(async (_dir, id) => {
+        if (id === 'plan-notfound')
+            return null;
+        return {
+            filePath: `/tmp/plans/${id}-test.md`,
+            header: { planId: id, taskId: 'ws-001', status: 'REVIEW', title: 'Test Plan', project: 'discoclaw', created: '2026-01-01' },
+        };
+    }),
+    listPlanFiles: vi.fn(async () => []),
+}));
+vi.mock('./forge-commands.js', () => ({
+    buildPlanSummary: vi.fn(() => '**plan-042** — Test Plan\nStatus: REVIEW'),
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeCtx() {
+    return {
+        guild: {},
+        client: {},
+        channelId: 'test-channel',
+        messageId: 'test-message',
+    };
+}
+function makeMockOrchestrator(overrides) {
+    return {
+        isRunning: overrides?.isRunning ?? false,
+        activePlanId: overrides?.activePlanId,
+        requestCancel: vi.fn(),
+        run: vi.fn(async () => ({
+            planId: 'plan-042',
+            filePath: '/tmp/plans/plan-042-test.md',
+            finalVerdict: 'minor',
+            rounds: 2,
+            reachedMaxRounds: false,
+        })),
+        resume: vi.fn(async () => ({
+            planId: 'plan-042',
+            filePath: '/tmp/plans/plan-042-test.md',
+            finalVerdict: 'minor',
+            rounds: 1,
+            reachedMaxRounds: false,
+        })),
+    };
+}
+function makeForgeCtx(overrides) {
+    const mockOrch = makeMockOrchestrator();
+    return {
+        orchestratorFactory: vi.fn(() => mockOrch),
+        plansDir: '/tmp/plans',
+        workspaceCwd: '/tmp/workspace',
+        taskStore: new TaskStore(),
+        onProgress: vi.fn(async () => { }),
+        log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+beforeEach(() => {
+    _resetForTest();
+});
+describe('FORGE_ACTION_TYPES', () => {
+    it('contains all forge action types', () => {
+        expect(FORGE_ACTION_TYPES.has('forgeCreate')).toBe(true);
+        expect(FORGE_ACTION_TYPES.has('forgeResume')).toBe(true);
+        expect(FORGE_ACTION_TYPES.has('forgeStatus')).toBe(true);
+        expect(FORGE_ACTION_TYPES.has('forgeCancel')).toBe(true);
+    });
+    it('does not contain non-forge types', () => {
+        expect(FORGE_ACTION_TYPES.has('beadCreate')).toBe(false);
+        expect(FORGE_ACTION_TYPES.has('cronCreate')).toBe(false);
+    });
+});
+describe('executeForgeAction', () => {
+    describe('forgeCreate', () => {
+        it('starts a forge run and returns summary', async () => {
+            const forgeCtx = makeForgeCtx();
+            const result = await executeForgeAction({ type: 'forgeCreate', description: 'Add retry logic' }, makeCtx(), forgeCtx);
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                expect(result.summary).toContain('Forge started');
+                expect(result.summary).toContain('Add retry logic');
+            }
+            expect(forgeCtx.orchestratorFactory).toHaveBeenCalled();
+        });
+        it('fails without description', async () => {
+            const result = await executeForgeAction({ type: 'forgeCreate', description: '' }, makeCtx(), makeForgeCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('requires a description');
+        });
+        it('blocks at recursion depth >= 1', async () => {
+            const result = await executeForgeAction({ type: 'forgeCreate', description: 'New thing' }, makeCtx(), makeForgeCtx({ depth: 1 }));
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('recursion depth');
+        });
+        it('rejects when a forge is already running', async () => {
+            const runningOrch = makeMockOrchestrator({ isRunning: true, activePlanId: 'plan-001' });
+            setActiveOrchestrator(runningOrch);
+            const result = await executeForgeAction({ type: 'forgeCreate', description: 'New thing' }, makeCtx(), makeForgeCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok) {
+                expect(result.error).toContain('already running');
+                expect(result.error).toContain('plan-001');
+            }
+        });
+    });
+    describe('forgeResume', () => {
+        it('resumes forge on existing plan', async () => {
+            const forgeCtx = makeForgeCtx();
+            const result = await executeForgeAction({ type: 'forgeResume', planId: 'plan-042' }, makeCtx(), forgeCtx);
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                expect(result.summary).toContain('Forge resumed');
+                expect(result.summary).toContain('plan-042');
+            }
+        });
+        it('blocks at recursion depth >= 1', async () => {
+            const result = await executeForgeAction({ type: 'forgeResume', planId: 'plan-042' }, makeCtx(), makeForgeCtx({ depth: 1 }));
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('recursion depth');
+        });
+        it('fails without planId', async () => {
+            const result = await executeForgeAction({ type: 'forgeResume', planId: '' }, makeCtx(), makeForgeCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('requires a planId');
+        });
+        it('fails when plan not found', async () => {
+            const result = await executeForgeAction({ type: 'forgeResume', planId: 'plan-notfound' }, makeCtx(), makeForgeCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('Plan not found');
+        });
+        it('rejects when a forge is already running', async () => {
+            const runningOrch = makeMockOrchestrator({ isRunning: true });
+            setActiveOrchestrator(runningOrch);
+            const result = await executeForgeAction({ type: 'forgeResume', planId: 'plan-042' }, makeCtx(), makeForgeCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('already running');
+        });
+    });
+    describe('forgeStatus', () => {
+        it('reports when no forge is running', async () => {
+            const result = await executeForgeAction({ type: 'forgeStatus' }, makeCtx(), makeForgeCtx());
+            expect(result.ok).toBe(true);
+            if (result.ok)
+                expect(result.summary).toContain('No forge');
+        });
+        it('reports active forge with plan ID', async () => {
+            const runningOrch = makeMockOrchestrator({ isRunning: true, activePlanId: 'plan-007' });
+            setActiveOrchestrator(runningOrch);
+            const result = await executeForgeAction({ type: 'forgeStatus' }, makeCtx(), makeForgeCtx());
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                expect(result.summary).toContain('running');
+                expect(result.summary).toContain('plan-007');
+            }
+        });
+    });
+    describe('forgeCancel', () => {
+        it('cancels a running forge', async () => {
+            const runningOrch = makeMockOrchestrator({ isRunning: true, activePlanId: 'plan-010' });
+            setActiveOrchestrator(runningOrch);
+            const result = await executeForgeAction({ type: 'forgeCancel' }, makeCtx(), makeForgeCtx());
+            expect(result.ok).toBe(true);
+            if (result.ok)
+                expect(result.summary).toContain('Cancel requested');
+            expect(runningOrch.requestCancel).toHaveBeenCalled();
+        });
+        it('fails when no forge is running', async () => {
+            const result = await executeForgeAction({ type: 'forgeCancel' }, makeCtx(), makeForgeCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('No forge');
+        });
+    });
+});
+describe('forgeActionsPromptSection', () => {
+    it('returns non-empty prompt section', () => {
+        const section = forgeActionsPromptSection();
+        expect(section).toContain('forgeCreate');
+        expect(section).toContain('forgeResume');
+        expect(section).toContain('forgeStatus');
+        expect(section).toContain('forgeCancel');
+    });
+    it('includes forge guidelines', () => {
+        const section = forgeActionsPromptSection();
+        expect(section).toContain('one forge');
+        expect(section).toContain('asynchronous');
+    });
+});