discoclaw 0.1.0

package/dist/discord/actions-config.js

@@ -0,0 +1,173 @@
+import { resolveModel } from '../runtime/model-tiers.js';
+const CONFIG_TYPE_MAP = {
+    modelSet: true,
+    modelShow: true,
+};
+export const CONFIG_ACTION_TYPES = new Set(Object.keys(CONFIG_TYPE_MAP));
+// ---------------------------------------------------------------------------
+// Role → field mapping
+// ---------------------------------------------------------------------------
+const ROLE_DESCRIPTIONS = {
+    chat: 'Discord messages, plan runs, deferred runs, forge fallback',
+    fast: 'All small/fast tasks (summary, cron, cron auto-tag, tasks auto-tag)',
+    'forge-drafter': 'Forge plan drafting/revision',
+    'forge-auditor': 'Forge plan auditing',
+    summary: 'Rolling summaries only',
+    cron: 'Cron auto-tagging and model classification',
+    'cron-exec': 'Default model for cron job execution (overridden by per-job settings)',
+};
+// ---------------------------------------------------------------------------
+// Executor
+// ---------------------------------------------------------------------------
+export function executeConfigAction(action, configCtx) {
+    switch (action.type) {
+        case 'modelSet': {
+            if (!action.role || !action.model) {
+                return { ok: false, error: 'modelSet requires role and model' };
+            }
+            const model = action.model.trim();
+            if (!model || /\s/.test(model)) {
+                return { ok: false, error: `Invalid model string: "${action.model}"` };
+            }
+            // Validate the model string resolves (non-empty result from resolveModel).
+            const resolved = resolveModel(model, configCtx.runtime.id);
+            if (resolved === '' && model !== '') {
+                // Tier name that doesn't map for this runtime — warn but allow.
+            }
+            const bp = configCtx.botParams;
+            const changes = [];
+            switch (action.role) {
+                case 'chat':
+                    bp.runtimeModel = model;
+                    if (bp.planCtx)
+                        bp.planCtx.model = model;
+                    if (bp.cronCtx?.executorCtx)
+                        bp.cronCtx.executorCtx.model = model;
+                    changes.push(`chat → ${model}`);
+                    break;
+                case 'fast':
+                    bp.summaryModel = model;
+                    changes.push(`summary → ${model}`);
+                    if (bp.cronCtx) {
+                        bp.cronCtx.autoTagModel = model;
+                        bp.cronCtx.syncCoordinator?.setAutoTagModel(model);
+                        changes.push(`cron-auto-tag → ${model}`);
+                    }
+                    if (bp.taskCtx) {
+                        bp.taskCtx.autoTagModel = model;
+                        changes.push(`tasks-auto-tag → ${model}`);
+                    }
+                    break;
+                case 'forge-drafter':
+                    bp.forgeDrafterModel = model;
+                    changes.push(`forge-drafter → ${model}`);
+                    break;
+                case 'forge-auditor':
+                    bp.forgeAuditorModel = model;
+                    changes.push(`forge-auditor → ${model}`);
+                    break;
+                case 'summary':
+                    bp.summaryModel = model;
+                    changes.push(`summary → ${model}`);
+                    break;
+                case 'cron':
+                    if (bp.cronCtx) {
+                        bp.cronCtx.autoTagModel = model;
+                        bp.cronCtx.syncCoordinator?.setAutoTagModel(model);
+                        changes.push(`cron → ${model}`);
+                    }
+                    else {
+                        return { ok: false, error: 'Cron subsystem not configured' };
+                    }
+                    break;
+                case 'cron-exec':
+                    if (bp.cronCtx?.executorCtx) {
+                        if (model === 'default') {
+                            bp.cronCtx.executorCtx.cronExecModel = undefined;
+                            changes.push(`cron-exec → (follows chat)`);
+                        }
+                        else {
+                            bp.cronCtx.executorCtx.cronExecModel = model;
+                            changes.push(`cron-exec → ${model}`);
+                        }
+                    }
+                    else {
+                        return { ok: false, error: 'Cron subsystem not configured' };
+                    }
+                    break;
+                default:
+                    return { ok: false, error: `Unknown role: ${action.role}` };
+            }
+            const resolvedDisplay = resolveModel(model, configCtx.runtime.id);
+            const resolvedNote = resolvedDisplay && resolvedDisplay !== model ? ` (resolves to ${resolvedDisplay})` : '';
+            return { ok: true, summary: `Model updated: ${changes.join(', ')}${resolvedNote}` };
+        }
+        case 'modelShow': {
+            const bp = configCtx.botParams;
+            const rid = configCtx.runtime.id;
+            const rows = [
+                ['chat', bp.runtimeModel, ROLE_DESCRIPTIONS.chat],
+                ['summary', bp.summaryModel, ROLE_DESCRIPTIONS.summary],
+                ['forge-drafter', bp.forgeDrafterModel ?? bp.runtimeModel, ROLE_DESCRIPTIONS['forge-drafter']],
+                ['forge-auditor', bp.forgeAuditorModel ?? bp.runtimeModel, ROLE_DESCRIPTIONS['forge-auditor']],
+            ];
+            if (bp.cronCtx) {
+                const cronExecModel = bp.cronCtx.executorCtx?.cronExecModel;
+                rows.push(['cron-exec', cronExecModel || `${bp.runtimeModel} (follows chat)`, ROLE_DESCRIPTIONS['cron-exec']]);
+                rows.push(['cron-auto-tag', bp.cronCtx.autoTagModel, ROLE_DESCRIPTIONS.cron]);
+            }
+            const taskAutoTagModel = bp.taskCtx?.autoTagModel;
+            if (taskAutoTagModel) {
+                rows.push(['tasks-auto-tag', taskAutoTagModel, 'Tasks auto-tagging']);
+            }
+            const adapterDefault = configCtx.runtime.defaultModel;
+            const lines = rows.map(([role, model, desc]) => {
+                const resolved = resolveModel(model, rid);
+                let display;
+                if (model) {
+                    display = resolved && resolved !== model ? `${model} → ${resolved}` : model;
+                }
+                else {
+                    display = adapterDefault || '(adapter default)';
+                }
+                return `**${role}**: \`${display}\` — ${desc}`;
+            });
+            return { ok: true, summary: lines.join('\n') };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Prompt section
+// ---------------------------------------------------------------------------
+export function configActionsPromptSection() {
+    return `### Model Configuration
+
+**modelShow** — Show current model assignments for all roles:
+\`\`\`
+<discord-action>{"type":"modelShow"}</discord-action>
+\`\`\`
+
+**modelSet** — Change the model for a role at runtime:
+\`\`\`
+<discord-action>{"type":"modelSet","role":"chat","model":"sonnet"}</discord-action>
+<discord-action>{"type":"modelSet","role":"fast","model":"haiku"}</discord-action>
+\`\`\`
+- \`role\` (required): One of \`chat\`, \`fast\`, \`forge-drafter\`, \`forge-auditor\`, \`summary\`, \`cron\`, \`cron-exec\`.
+- \`model\` (required): Model tier (\`fast\`, \`capable\`), concrete model name (\`haiku\`, \`sonnet\`, \`opus\`), or \`default\` (for cron-exec only, to revert to following chat).
+
+**Roles:**
+| Role | What it controls |
+|------|-----------------|
+| \`chat\` | Discord messages, plan runs, deferred runs, forge fallback |
+| \`fast\` | All small/fast tasks (summary, cron auto-tag, tasks auto-tag) |
+| \`forge-drafter\` | Forge plan drafting/revision |
+| \`forge-auditor\` | Forge plan auditing |
+| \`summary\` | Rolling summaries only (overrides fast) |
+| \`cron\` | Cron auto-tagging and model classification (overrides fast) |
+| \`cron-exec\` | Default model for cron job execution; per-job overrides (via \`cronUpdate\`) take priority |
+
+Changes are **ephemeral** — they take effect immediately but revert on restart. Use env vars for persistent configuration.
+
+**Cron model priority:** per-job override (cronUpdate) > AI-classified model > cron-exec default > chat fallback.
+Set \`cron-exec\` to \`default\` to clear the override and fall back to the chat model.`;
+}

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

@@ -0,0 +1,322 @@
+import { describe, expect, it } from 'vitest';
+import { CONFIG_ACTION_TYPES, executeConfigAction, configActionsPromptSection } from './actions-config.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeBotParams(overrides) {
+    return {
+        runtimeModel: 'capable',
+        summaryModel: 'fast',
+        forgeDrafterModel: undefined,
+        forgeAuditorModel: undefined,
+        cronCtx: { autoTagModel: 'fast', executorCtx: { model: 'capable' } },
+        taskCtx: { autoTagModel: 'fast' },
+        ...overrides,
+    };
+}
+const stubRuntime = {
+    id: 'claude_code',
+    capabilities: new Set(),
+    async *invoke() { },
+};
+function makeCtx(overrides) {
+    return {
+        botParams: makeBotParams(overrides),
+        runtime: stubRuntime,
+    };
+}
+// ---------------------------------------------------------------------------
+// CONFIG_ACTION_TYPES
+// ---------------------------------------------------------------------------
+describe('CONFIG_ACTION_TYPES', () => {
+    it('includes modelSet and modelShow', () => {
+        expect(CONFIG_ACTION_TYPES.has('modelSet')).toBe(true);
+        expect(CONFIG_ACTION_TYPES.has('modelShow')).toBe(true);
+        expect(CONFIG_ACTION_TYPES.size).toBe(2);
+    });
+});
+// ---------------------------------------------------------------------------
+// modelShow
+// ---------------------------------------------------------------------------
+describe('modelShow', () => {
+    it('returns current model assignments', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelShow' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.summary).toContain('chat');
+        expect(result.summary).toContain('capable');
+        expect(result.summary).toContain('summary');
+        expect(result.summary).toContain('forge-drafter');
+        expect(result.summary).toContain('forge-auditor');
+        expect(result.summary).toContain('cron');
+    });
+    it('shows forge models falling back to runtimeModel', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelShow' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        // forge-drafter should show runtimeModel since forgeDrafterModel is undefined
+        expect(result.summary).toContain('forge-drafter');
+        expect(result.summary).toContain('capable');
+    });
+    it('shows explicit forge model override', () => {
+        const ctx = makeCtx({ forgeDrafterModel: 'sonnet' });
+        const result = executeConfigAction({ type: 'modelShow' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.summary).toContain('sonnet');
+    });
+    it('resolves tier names to concrete models for claude_code runtime', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelShow' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        // 'capable' resolves to 'opus' for claude_code
+        expect(result.summary).toContain('opus');
+        // 'fast' resolves to 'haiku' for claude_code
+        expect(result.summary).toContain('haiku');
+    });
+    it('omits cron row when cronCtx is not set', () => {
+        const ctx = makeCtx({ cronCtx: undefined });
+        const result = executeConfigAction({ type: 'modelShow' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.summary).not.toContain('cron-auto-tag');
+    });
+    it('labels cron row as cron-auto-tag', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelShow' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.summary).toContain('cron-auto-tag');
+    });
+    it('shows cron-exec following chat when no override set', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelShow' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.summary).toContain('cron-exec');
+        expect(result.summary).toContain('follows chat');
+    });
+    it('shows explicit cron-exec model when set', () => {
+        const ctx = makeCtx();
+        ctx.botParams.cronCtx.executorCtx.cronExecModel = 'haiku';
+        const result = executeConfigAction({ type: 'modelShow' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.summary).toContain('cron-exec');
+        expect(result.summary).toContain('haiku');
+        expect(result.summary).not.toContain('follows chat');
+    });
+    it('shows runtime defaultModel when model value is empty', () => {
+        const codexRuntime = {
+            id: 'codex',
+            capabilities: new Set(),
+            defaultModel: 'gpt-5-codex-mini',
+            async *invoke() { },
+        };
+        const ctx = {
+            botParams: makeBotParams({ runtimeModel: '', summaryModel: '' }),
+            runtime: codexRuntime,
+        };
+        const result = executeConfigAction({ type: 'modelShow' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.summary).toContain('gpt-5-codex-mini');
+        expect(result.summary).not.toContain('(adapter default)');
+    });
+    it('falls back to (adapter default) when both model and defaultModel are empty', () => {
+        const codexRuntime = {
+            id: 'codex',
+            capabilities: new Set(),
+            async *invoke() { },
+        };
+        const ctx = {
+            botParams: makeBotParams({ runtimeModel: '', summaryModel: '' }),
+            runtime: codexRuntime,
+        };
+        const result = executeConfigAction({ type: 'modelShow' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.summary).toContain('(adapter default)');
+    });
+});
+// ---------------------------------------------------------------------------
+// modelSet
+// ---------------------------------------------------------------------------
+describe('modelSet', () => {
+    it('sets chat model (runtimeModel)', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelSet', role: 'chat', model: 'sonnet' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ctx.botParams.runtimeModel).toBe('sonnet');
+    });
+    it('sets all fast-tier models at once', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelSet', role: 'fast', model: 'haiku' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ctx.botParams.summaryModel).toBe('haiku');
+        expect(ctx.botParams.cronCtx.autoTagModel).toBe('haiku');
+        expect(ctx.botParams.taskCtx.autoTagModel).toBe('haiku');
+    });
+    it('sets forge-drafter model', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelSet', role: 'forge-drafter', model: 'opus' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ctx.botParams.forgeDrafterModel).toBe('opus');
+    });
+    it('sets forge-auditor model', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelSet', role: 'forge-auditor', model: 'sonnet' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ctx.botParams.forgeAuditorModel).toBe('sonnet');
+    });
+    it('sets summary model independently', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelSet', role: 'summary', model: 'capable' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ctx.botParams.summaryModel).toBe('capable');
+    });
+    it('sets cron model', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelSet', role: 'cron', model: 'capable' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ctx.botParams.cronCtx.autoTagModel).toBe('capable');
+    });
+    it('rejects empty model string', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelSet', role: 'chat', model: '' }, ctx);
+        expect(result.ok).toBe(false);
+    });
+    it('rejects model with whitespace', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelSet', role: 'chat', model: 'some model' }, ctx);
+        expect(result.ok).toBe(false);
+    });
+    it('rejects missing role', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelSet', role: '', model: 'sonnet' }, ctx);
+        expect(result.ok).toBe(false);
+    });
+    it('rejects missing model', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelSet', role: 'chat', model: '' }, ctx);
+        expect(result.ok).toBe(false);
+    });
+    it('fails for cron role when cronCtx is not configured', () => {
+        const ctx = makeCtx({ cronCtx: undefined });
+        const result = executeConfigAction({ type: 'modelSet', role: 'cron', model: 'fast' }, ctx);
+        expect(result.ok).toBe(false);
+        if (result.ok)
+            return;
+        expect(result.error).toContain('Cron subsystem not configured');
+    });
+    it('includes resolved model note for tier names', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelSet', role: 'chat', model: 'capable' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.summary).toContain('resolves to opus');
+    });
+    it('fast role succeeds when cronCtx and taskCtx are missing', () => {
+        const ctx = makeCtx({ cronCtx: undefined, taskCtx: undefined });
+        const result = executeConfigAction({ type: 'modelSet', role: 'fast', model: 'haiku' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ctx.botParams.summaryModel).toBe('haiku');
+        if (!result.ok)
+            return;
+        // Only summary changed, cron/beads skipped silently
+        expect(result.summary).toContain('summary');
+        expect(result.summary).not.toContain('cron');
+        expect(result.summary).not.toContain('beads');
+    });
+    it('accepts concrete model names as passthrough', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelSet', role: 'chat', model: 'claude-sonnet-4-5-20250929' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ctx.botParams.runtimeModel).toBe('claude-sonnet-4-5-20250929');
+    });
+    it('chat propagates to planCtx.model', () => {
+        const ctx = makeCtx();
+        ctx.botParams.planCtx = { model: 'old' };
+        executeConfigAction({ type: 'modelSet', role: 'chat', model: 'sonnet' }, ctx);
+        expect(ctx.botParams.planCtx.model).toBe('sonnet');
+    });
+    it('chat propagates to cronCtx.executorCtx.model', () => {
+        const ctx = makeCtx();
+        ctx.botParams.cronCtx.executorCtx = { model: 'old' };
+        executeConfigAction({ type: 'modelSet', role: 'chat', model: 'sonnet' }, ctx);
+        expect(ctx.botParams.cronCtx.executorCtx.model).toBe('sonnet');
+    });
+    it('fast propagates to cronCtx.syncCoordinator', () => {
+        let updated = '';
+        const ctx = makeCtx();
+        ctx.botParams.cronCtx.syncCoordinator = { setAutoTagModel: (m) => { updated = m; } };
+        executeConfigAction({ type: 'modelSet', role: 'fast', model: 'haiku' }, ctx);
+        expect(updated).toBe('haiku');
+    });
+    it('cron propagates to cronCtx.syncCoordinator', () => {
+        let updated = '';
+        const ctx = makeCtx();
+        ctx.botParams.cronCtx.syncCoordinator = { setAutoTagModel: (m) => { updated = m; } };
+        executeConfigAction({ type: 'modelSet', role: 'cron', model: 'capable' }, ctx);
+        expect(updated).toBe('capable');
+    });
+    it('chat skips planCtx/cronExecCtx propagation when not configured', () => {
+        const ctx = makeCtx();
+        // No planCtx or cronCtx.executorCtx — should not throw
+        ctx.botParams.planCtx = undefined;
+        const result = executeConfigAction({ type: 'modelSet', role: 'chat', model: 'sonnet' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ctx.botParams.runtimeModel).toBe('sonnet');
+    });
+    it('sets cron-exec model', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelSet', role: 'cron-exec', model: 'haiku' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ctx.botParams.cronCtx.executorCtx.cronExecModel).toBe('haiku');
+    });
+    it('cron-exec "default" clears the override', () => {
+        const ctx = makeCtx();
+        ctx.botParams.cronCtx.executorCtx.cronExecModel = 'haiku';
+        const result = executeConfigAction({ type: 'modelSet', role: 'cron-exec', model: 'default' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ctx.botParams.cronCtx.executorCtx.cronExecModel).toBeUndefined();
+        if (!result.ok)
+            return;
+        expect(result.summary).toContain('follows chat');
+    });
+    it('cron-exec fails when cron subsystem not configured', () => {
+        const ctx = makeCtx({ cronCtx: undefined });
+        const result = executeConfigAction({ type: 'modelSet', role: 'cron-exec', model: 'haiku' }, ctx);
+        expect(result.ok).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// configActionsPromptSection
+// ---------------------------------------------------------------------------
+describe('configActionsPromptSection', () => {
+    it('documents modelSet and modelShow', () => {
+        const section = configActionsPromptSection();
+        expect(section).toContain('modelShow');
+        expect(section).toContain('modelSet');
+        expect(section).toContain('role');
+        expect(section).toContain('chat');
+        expect(section).toContain('fast');
+        expect(section).toContain('forge-drafter');
+        expect(section).toContain('forge-auditor');
+        expect(section).toContain('ephemeral');
+    });
+});