discoclaw 0.1.0

package/dist/discord/actions-moderation.js

@@ -0,0 +1,65 @@
+const MODERATION_TYPE_MAP = {
+    timeout: true, kick: true, ban: true,
+};
+export const MODERATION_ACTION_TYPES = new Set(Object.keys(MODERATION_TYPE_MAP));
+// ---------------------------------------------------------------------------
+// Executor
+// ---------------------------------------------------------------------------
+export async function executeModerationAction(action, ctx) {
+    const { guild } = ctx;
+    switch (action.type) {
+        case 'timeout': {
+            const member = await guild.members.fetch(action.userId).catch(() => null);
+            if (!member)
+                return { ok: false, error: `Member "${action.userId}" not found` };
+            const minutes = action.durationMinutes ?? 5;
+            const ms = minutes * 60 * 1000;
+            await member.timeout(ms, action.reason);
+            return { ok: true, summary: `Timed out ${member.displayName} for ${minutes} minutes${action.reason ? `: ${action.reason}` : ''}` };
+        }
+        case 'kick': {
+            const member = await guild.members.fetch(action.userId).catch(() => null);
+            if (!member)
+                return { ok: false, error: `Member "${action.userId}" not found` };
+            const name = member.displayName;
+            await member.kick(action.reason);
+            return { ok: true, summary: `Kicked ${name}${action.reason ? `: ${action.reason}` : ''}` };
+        }
+        case 'ban': {
+            const member = await guild.members.fetch(action.userId).catch(() => null);
+            if (!member)
+                return { ok: false, error: `Member "${action.userId}" not found` };
+            const name = member.displayName;
+            await member.ban({
+                reason: action.reason,
+                deleteMessageSeconds: (action.deleteMessageDays ?? 0) * 86400,
+            });
+            return { ok: true, summary: `Banned ${name}${action.reason ? `: ${action.reason}` : ''}` };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Prompt section
+// ---------------------------------------------------------------------------
+export function moderationActionsPromptSection() {
+    return `### Moderation
+
+All moderation actions are destructive. **Always confirm with the user before executing.**
+
+**timeout** — Temporarily mute a member:
+\`\`\`
+<discord-action>{"type":"timeout","userId":"123","durationMinutes":10,"reason":"Spamming"}</discord-action>
+\`\`\`
+- \`durationMinutes\` (optional): Default 5 minutes.
+
+**kick** — Kick a member from the server:
+\`\`\`
+<discord-action>{"type":"kick","userId":"123","reason":"Rule violation"}</discord-action>
+\`\`\`
+
+**ban** — Ban a member from the server:
+\`\`\`
+<discord-action>{"type":"ban","userId":"123","reason":"Repeated violations","deleteMessageDays":1}</discord-action>
+\`\`\`
+- \`deleteMessageDays\` (optional): Delete messages from the last N days (0–7).`;
+}

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

@@ -0,0 +1,88 @@
+import { describe, expect, it, vi } from 'vitest';
+import { executeModerationAction } from './actions-moderation.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeMockMember(overrides = {}) {
+    return {
+        id: overrides.id ?? 'user1',
+        displayName: overrides.displayName ?? 'TestUser',
+        user: { username: overrides.username ?? 'testuser' },
+        timeout: vi.fn(async () => { }),
+        kick: vi.fn(async () => { }),
+        ban: vi.fn(async () => { }),
+    };
+}
+function makeCtx(members) {
+    const memberMap = new Map();
+    for (const m of members)
+        memberMap.set(m.id, m);
+    return {
+        guild: {
+            members: {
+                fetch: vi.fn(async (id) => {
+                    const m = memberMap.get(id);
+                    if (!m)
+                        throw new Error('not found');
+                    return m;
+                }),
+            },
+        },
+        client: {},
+        channelId: 'ch1',
+        messageId: 'msg1',
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('timeout', () => {
+    it('times out a member with default duration', async () => {
+        const member = makeMockMember({ id: 'u1', displayName: 'Alice' });
+        const ctx = makeCtx([member]);
+        const result = await executeModerationAction({ type: 'timeout', userId: 'u1' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Timed out Alice for 5 minutes' });
+        expect(member.timeout).toHaveBeenCalledWith(5 * 60 * 1000, undefined);
+    });
+    it('times out with custom duration and reason', async () => {
+        const member = makeMockMember({ id: 'u1', displayName: 'Bob' });
+        const ctx = makeCtx([member]);
+        const result = await executeModerationAction({ type: 'timeout', userId: 'u1', durationMinutes: 30, reason: 'Spamming' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('30 minutes');
+        expect(result.summary).toContain('Spamming');
+        expect(member.timeout).toHaveBeenCalledWith(30 * 60 * 1000, 'Spamming');
+    });
+    it('fails when member not found', async () => {
+        const ctx = makeCtx([]);
+        const result = await executeModerationAction({ type: 'timeout', userId: 'nope' }, ctx);
+        expect(result).toEqual({ ok: false, error: 'Member "nope" not found' });
+    });
+});
+describe('kick', () => {
+    it('kicks a member', async () => {
+        const member = makeMockMember({ id: 'u1', displayName: 'Spammer' });
+        const ctx = makeCtx([member]);
+        const result = await executeModerationAction({ type: 'kick', userId: 'u1', reason: 'Rule violation' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Kicked Spammer: Rule violation' });
+        expect(member.kick).toHaveBeenCalledWith('Rule violation');
+    });
+});
+describe('ban', () => {
+    it('bans a member with message deletion', async () => {
+        const member = makeMockMember({ id: 'u1', displayName: 'BadActor' });
+        const ctx = makeCtx([member]);
+        const result = await executeModerationAction({ type: 'ban', userId: 'u1', reason: 'Repeated violations', deleteMessageDays: 7 }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Banned BadActor: Repeated violations' });
+        expect(member.ban).toHaveBeenCalledWith({
+            reason: 'Repeated violations',
+            deleteMessageSeconds: 7 * 86400,
+        });
+    });
+    it('bans without reason', async () => {
+        const member = makeMockMember({ id: 'u1', displayName: 'User' });
+        const ctx = makeCtx([member]);
+        const result = await executeModerationAction({ type: 'ban', userId: 'u1' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Banned User' });
+    });
+});

package/dist/discord/actions-plan.js

@@ -0,0 +1,445 @@
+import { findPlanFile, listPlanFiles, updatePlanFileStatus, handlePlanCommand, preparePlanRun, closePlanIfComplete, resolvePlanHeaderTaskId, NO_PHASES_SENTINEL, } from './plan-commands.js';
+import { runNextPhase, resolveProjectCwd, readPhasesFile, buildPostRunSummary } from './plan-manager.js';
+import { acquireWriterLock, addRunningPlan, removeRunningPlan, isPlanRunning, } from './forge-plan-registry.js';
+import { NO_MENTIONS } from './allowed-mentions.js';
+const DEFAULT_PLAN_PHASE_TIMEOUT_MS = 1_800_000;
+const PLAN_TYPE_MAP = {
+    planList: true,
+    planShow: true,
+    planApprove: true,
+    planClose: true,
+    planCreate: true,
+    planRun: true,
+};
+export const PLAN_ACTION_TYPES = new Set(Object.keys(PLAN_TYPE_MAP));
+// ---------------------------------------------------------------------------
+// Executor
+// ---------------------------------------------------------------------------
+export async function executePlanAction(action, ctx, planCtx) {
+    switch (action.type) {
+        case 'planList': {
+            const plans = await listPlanFiles(planCtx.plansDir);
+            if (plans.length === 0) {
+                return { ok: true, summary: 'No plans found.' };
+            }
+            // Filter by status if provided.
+            let filtered = plans;
+            if (action.status) {
+                const statusUpper = action.status.toUpperCase();
+                filtered = plans.filter((p) => p.header.status.toUpperCase() === statusUpper);
+                if (filtered.length === 0) {
+                    return { ok: true, summary: `No plans with status "${action.status}".` };
+                }
+            }
+            // Sort by planId.
+            filtered.sort((a, b) => a.header.planId.localeCompare(b.header.planId));
+            const lines = filtered.map((p) => {
+                const taskId = resolvePlanHeaderTaskId(p.header);
+                return `\`${p.header.planId}\` [${p.header.status}] — ${p.header.title}${taskId ? ` (task: \`${taskId}\`)` : ''}`;
+            });
+            return { ok: true, summary: lines.join('\n') };
+        }
+        case 'planShow': {
+            if (!action.planId) {
+                return { ok: false, error: 'planShow requires a planId' };
+            }
+            const found = await findPlanFile(planCtx.plansDir, action.planId);
+            if (!found) {
+                return { ok: false, error: `Plan not found: ${action.planId}` };
+            }
+            const taskId = resolvePlanHeaderTaskId(found.header);
+            const lines = [
+                `**${found.header.planId}** — ${found.header.title}`,
+                `Status: ${found.header.status}`,
+                ...(taskId ? [`Task: \`${taskId}\``] : []),
+                `Project: ${found.header.project}`,
+                `Created: ${found.header.created}`,
+            ];
+            return { ok: true, summary: lines.join('\n') };
+        }
+        case 'planApprove': {
+            if (!action.planId) {
+                return { ok: false, error: 'planApprove requires a planId' };
+            }
+            const found = await findPlanFile(planCtx.plansDir, action.planId);
+            if (!found) {
+                return { ok: false, error: `Plan not found: ${action.planId}` };
+            }
+            if (found.header.status === 'IMPLEMENTING') {
+                return {
+                    ok: false,
+                    error: `Plan is currently being implemented. Cancel it first.`,
+                };
+            }
+            await updatePlanFileStatus(found.filePath, 'APPROVED');
+            // Update backing task to in_progress.
+            const taskId = resolvePlanHeaderTaskId(found.header);
+            if (taskId) {
+                try {
+                    planCtx.taskStore.update(taskId, { status: 'in_progress' });
+                }
+                catch {
+                    // best-effort
+                }
+            }
+            return { ok: true, summary: `Plan **${found.header.planId}** approved for implementation.` };
+        }
+        case 'planClose': {
+            if (!action.planId) {
+                return { ok: false, error: 'planClose requires a planId' };
+            }
+            const found = await findPlanFile(planCtx.plansDir, action.planId);
+            if (!found) {
+                return { ok: false, error: `Plan not found: ${action.planId}` };
+            }
+            if (found.header.status === 'IMPLEMENTING') {
+                return {
+                    ok: false,
+                    error: `Plan is currently being implemented. Cancel it first.`,
+                };
+            }
+            await updatePlanFileStatus(found.filePath, 'CLOSED');
+            // Close backing task.
+            const taskId = resolvePlanHeaderTaskId(found.header);
+            if (taskId) {
+                try {
+                    planCtx.taskStore.close(taskId, 'Plan closed');
+                }
+                catch {
+                    // best-effort
+                }
+            }
+            return { ok: true, summary: `Plan **${found.header.planId}** closed.` };
+        }
+        case 'planCreate': {
+            if (!action.description) {
+                return { ok: false, error: 'planCreate requires a description' };
+            }
+            const opts = {
+                workspaceCwd: planCtx.workspaceCwd,
+                taskStore: planCtx.taskStore,
+            };
+            const result = await handlePlanCommand({ action: 'create', args: action.description, context: action.context }, opts);
+            // handlePlanCommand returns a human-readable string. Check for error patterns.
+            if (result.startsWith('Failed') || result.startsWith('Plan command error')) {
+                return { ok: false, error: result };
+            }
+            return { ok: true, summary: result };
+        }
+        case 'planRun': {
+            if ((planCtx.depth ?? 0) >= 1) {
+                return { ok: false, error: 'planRun blocked: recursion depth >= 1 (plan run cannot spawn another plan run)' };
+            }
+            if (!action.planId) {
+                return { ok: false, error: 'planRun requires a planId' };
+            }
+            if (!planCtx.runtime || !planCtx.model) {
+                return { ok: false, error: 'planRun requires runtime and model to be configured' };
+            }
+            if (isPlanRunning(action.planId)) {
+                return { ok: false, error: `A multi-phase run is already in progress for ${action.planId}.` };
+            }
+            const runPlanId = action.planId;
+            const planOpts = {
+                workspaceCwd: planCtx.workspaceCwd,
+                taskStore: planCtx.taskStore,
+            };
+            // Validate the plan and get phase info synchronously.
+            const prepResult = await preparePlanRun(action.planId, planOpts);
+            if ('error' in prepResult) {
+                const isAllDone = prepResult.error.startsWith(NO_PHASES_SENTINEL);
+                return isAllDone
+                    ? { ok: true, summary: `All phases already complete for ${action.planId}.` }
+                    : { ok: false, error: prepResult.error };
+            }
+            let projectCwd;
+            try {
+                projectCwd = resolveProjectCwd(prepResult.planContent, planCtx.workspaceCwd);
+            }
+            catch (err) {
+                return { ok: false, error: `Failed to resolve project directory: ${String(err instanceof Error ? err.message : err)}` };
+            }
+            const maxPhases = planCtx.maxPlanRunPhases ?? 50;
+            const timeoutMs = planCtx.phaseTimeoutMs ?? DEFAULT_PLAN_PHASE_TIMEOUT_MS;
+            const onProgress = planCtx.onProgress ?? (async () => { });
+            const PROGRESS_THROTTLE_MS = 3_000;
+            addRunningPlan(action.planId);
+            // Fire and forget — plan run executes asynchronously.
+            void (async () => {
+                // Send initial status message and set up live edits (best-effort).
+                let runChannel;
+                let statusMsg;
+                let lastStatusEditAt = 0;
+                const phaseStartMessages = new Map();
+                const onPlanEvent = async (event) => {
+                    if (event.type === 'phase_start') {
+                        if (phaseStartMessages.has(event.phase.id) || !runChannel)
+                            return;
+                        try {
+                            const sent = await runChannel.send({
+                                content: `**${event.phase.title}**...`,
+                                allowedMentions: NO_MENTIONS,
+                            });
+                            if (sent && typeof sent.edit === 'function') {
+                                phaseStartMessages.set(event.phase.id, sent);
+                            }
+                        }
+                        catch (err) {
+                            planCtx.log?.warn({ err, planId: runPlanId, phaseId: event.phase.id }, 'plan:action:run phase-start post failed');
+                        }
+                    }
+                    else if (event.type === 'phase_complete') {
+                        const phaseMsg = phaseStartMessages.get(event.phase.id);
+                        if (!phaseMsg)
+                            return;
+                        const indicator = event.status === 'done' ? '[x]' : event.status === 'failed' ? '[!]' : '[-]';
+                        try {
+                            await phaseMsg.edit({
+                                content: `${indicator} **${event.phase.title}**`,
+                                allowedMentions: NO_MENTIONS,
+                            });
+                        }
+                        catch {
+                            // best-effort
+                        }
+                    }
+                };
+                const phaseOpts = {
+                    runtime: planCtx.runtime,
+                    model: planCtx.model,
+                    projectCwd,
+                    addDirs: [],
+                    timeoutMs,
+                    workspaceCwd: planCtx.workspaceCwd,
+                    log: planCtx.log,
+                    maxAuditFixAttempts: planCtx.maxAuditFixAttempts,
+                    onPlanEvent,
+                };
+                try {
+                    const channel = await ctx.client.channels.fetch(ctx.channelId);
+                    if (channel && 'send' in channel) {
+                        runChannel = channel;
+                    }
+                }
+                catch {
+                    // best-effort — phase-start posts and completion fall back gracefully
+                }
+                if (!planCtx.skipCompletionNotify && runChannel) {
+                    try {
+                        const sent = await runChannel.send({
+                            content: `**Plan run started:** \`${runPlanId}\` — starting phase ${prepResult.nextPhase.id}: ${prepResult.nextPhase.title}`,
+                            allowedMentions: NO_MENTIONS,
+                        });
+                        if (sent && typeof sent.edit === 'function') {
+                            statusMsg = sent;
+                        }
+                    }
+                    catch {
+                        // best-effort — missing status message is non-fatal
+                    }
+                }
+                // Edit the status message, honouring throttle. Pass force=true to bypass throttle.
+                async function editStatus(content, force = false) {
+                    if (!statusMsg)
+                        return;
+                    const now = Date.now();
+                    if (!force && now - lastStatusEditAt < PROGRESS_THROTTLE_MS)
+                        return;
+                    lastStatusEditAt = now;
+                    try {
+                        await statusMsg.edit({ content, allowedMentions: NO_MENTIONS });
+                    }
+                    catch {
+                        // best-effort
+                    }
+                }
+                // Compose onProgress with status message edits.
+                const wrappedOnProgress = async (msg) => {
+                    await onProgress(msg);
+                    await editStatus(msg);
+                };
+                let phasesRun = 0;
+                let stopReason;
+                let stopMessage;
+                let hitMaxPhases = false;
+                for (let i = 0; i < maxPhases; i++) {
+                    const release = await acquireWriterLock();
+                    let phaseResult;
+                    try {
+                        phaseResult = await runNextPhase(prepResult.phasesFilePath, prepResult.planFilePath, phaseOpts, wrappedOnProgress);
+                    }
+                    finally {
+                        release();
+                    }
+                    if (phaseResult.result === 'done') {
+                        phasesRun++;
+                        // Force-edit on phase completion boundary.
+                        await editStatus(`**Plan run in progress:** \`${action.planId}\` — phase complete (${phasesRun} done so far)`, true);
+                    }
+                    else if (phaseResult.result === 'nothing_to_run') {
+                        // Force-edit to reflect no more phases.
+                        await editStatus(`**Plan run finishing:** \`${action.planId}\` — no more phases to run`, true);
+                        break;
+                    }
+                    else {
+                        // Any error/stale/corrupt/audit_failed/retry_blocked stops the loop.
+                        stopReason = phaseResult.result;
+                        stopMessage = phaseResult.error ?? phaseResult.message ?? phaseResult.result;
+                        planCtx.log?.warn({ planId: runPlanId, result: phaseResult.result, phasesRun }, 'plan:action:run stopped');
+                        // Force-edit to reflect stop.
+                        await editStatus(`**Plan run stopped:** \`${runPlanId}\` — ${stopMessage ?? stopReason}`, true);
+                        break;
+                    }
+                    if (i === maxPhases - 1) {
+                        hitMaxPhases = true;
+                    }
+                    // Yield between phases.
+                    await new Promise(resolve => setImmediate(resolve));
+                }
+                planCtx.log?.info({ planId: runPlanId, phasesRun }, 'plan:action:run complete');
+                // Auto-close plan if all phases are terminal
+                let autoClosed = false;
+                let runError;
+                try {
+                    const closeResult = await closePlanIfComplete(prepResult.phasesFilePath, prepResult.planFilePath, planCtx.taskStore, acquireWriterLock, planCtx.log);
+                    autoClosed = closeResult.closed;
+                }
+                catch (err) {
+                    runError = err;
+                    planCtx.log?.error({ err, planId: runPlanId }, 'plan:action:run failed');
+                }
+                // Build the final outcome content — always, so onRunComplete can use it even when skipCompletionNotify is set.
+                const lines = [
+                    `**Plan run complete:** \`${runPlanId}\``,
+                    `Phases run: ${phasesRun}`,
+                ];
+                if (hitMaxPhases && !stopReason) {
+                    lines.push(`Stopped: reached max-phase limit (${maxPhases})`);
+                }
+                if (stopReason) {
+                    lines.push(`Stopped: ${stopMessage ?? stopReason}`);
+                }
+                if (runError) {
+                    lines.push(`Error: ${runError instanceof Error ? runError.message : String(runError)}`);
+                }
+                if (autoClosed) {
+                    lines.push('Plan auto-closed — all phases terminal.');
+                }
+                try {
+                    const phases = readPhasesFile(prepResult.phasesFilePath, { log: planCtx.log });
+                    const budget = Math.max(0, 2000 - lines.join('\n').length - 50);
+                    const summary = buildPostRunSummary(phases, budget);
+                    if (summary) {
+                        lines.push(summary);
+                    }
+                }
+                catch (summaryErr) {
+                    planCtx.log?.error({ err: summaryErr, planId: runPlanId }, 'plan:action:run summary failed');
+                }
+                const finalContent = lines.join('\n');
+                // Edit status message to show final outcome (preserved for backwards compatibility).
+                if (!planCtx.skipCompletionNotify) {
+                    try {
+                        if (statusMsg) {
+                            // Edit the existing status message in place.
+                            try {
+                                await statusMsg.edit({ content: finalContent, allowedMentions: NO_MENTIONS });
+                            }
+                            catch {
+                                // best-effort
+                            }
+                        }
+                        // Post a standalone completion message as a new chat message.
+                        if (runChannel) {
+                            try {
+                                await runChannel.send({ content: finalContent, allowedMentions: NO_MENTIONS });
+                            }
+                            catch {
+                                // best-effort
+                            }
+                        }
+                        else if (!statusMsg) {
+                            // Fall back to sending a new message if we never got runChannel or statusMsg.
+                            try {
+                                const channel = await ctx.client.channels.fetch(ctx.channelId);
+                                if (channel && 'send' in channel) {
+                                    await channel.send({ content: finalContent, allowedMentions: NO_MENTIONS });
+                                }
+                            }
+                            catch {
+                                // best-effort
+                            }
+                        }
+                    }
+                    catch {
+                        // best-effort — do not rethrow
+                    }
+                }
+                // Notify caller (e.g. forge auto-implement) with the final content — best-effort.
+                try {
+                    await planCtx.onRunComplete?.(finalContent);
+                }
+                catch {
+                    // best-effort
+                }
+            })().catch((err) => {
+                planCtx.log?.error({ err, planId: runPlanId }, 'plan:action:run failed');
+            }).finally(() => {
+                removeRunningPlan(runPlanId);
+            });
+            return { ok: true, summary: `Plan run started for **${action.planId}** — starting phase ${prepResult.nextPhase.id}: ${prepResult.nextPhase.title}` };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Prompt section
+// ---------------------------------------------------------------------------
+export function planActionsPromptSection() {
+    return `### Plan Management
+
+**planList** — List all plans (optionally filter by status):
+\`\`\`
+<discord-action>{"type":"planList"}</discord-action>
+<discord-action>{"type":"planList","status":"APPROVED"}</discord-action>
+\`\`\`
+- \`status\` (optional): Filter by plan status (DRAFT, REVIEW, APPROVED, IMPLEMENTING, CLOSED).
+
+**planShow** — Show plan details:
+\`\`\`
+<discord-action>{"type":"planShow","planId":"plan-042"}</discord-action>
+\`\`\`
+- \`planId\` (required): The plan ID or backing task ID (legacy header IDs are still accepted).
+
+**planApprove** — Approve a plan for implementation:
+\`\`\`
+<discord-action>{"type":"planApprove","planId":"plan-042"}</discord-action>
+\`\`\`
+- \`planId\` (required): The plan ID to approve.
+
+**planClose** — Close/abandon a plan:
+\`\`\`
+<discord-action>{"type":"planClose","planId":"plan-042"}</discord-action>
+\`\`\`
+- \`planId\` (required): The plan ID to close.
+
+**planCreate** — Create a new plan (drafts a plan file and backing task):
+\`\`\`
+<discord-action>{"type":"planCreate","description":"Add retry logic to webhook handler","context":"Optional extra context"}</discord-action>
+\`\`\`
+- \`description\` (required): What the plan is for.
+- \`context\` (optional): Additional context appended to the plan.
+
+**planRun** — Execute all remaining phases of a plan (fire-and-forget):
+\`\`\`
+<discord-action>{"type":"planRun","planId":"plan-042"}</discord-action>
+\`\`\`
+- \`planId\` (required): The plan ID to execute.
+- The plan must be in APPROVED or IMPLEMENTING status. Phases run sequentially with the writer lock. On successful completion of all phases, the plan is auto-closed and the backing task is closed.
+
+#### Plan Guidelines
+- Use planList to check existing plans before creating duplicates.
+- Plans go through statuses: DRAFT → REVIEW → APPROVED → IMPLEMENTING → CLOSED.
+- Use forgeCreate to draft+audit a plan, or planCreate for a bare plan file without forge auditing.
+- Approving a plan marks its backing task as in_progress.
+- Use planRun to execute approved plans autonomously.`;
+}