skimpyclaw 0.3.14 → 0.4.0

package/dist/channels/discord/index.d.ts

@@ -1,8 +1,23 @@
 import type { Config } from '../../types.js';
+import { type DiscordTextAttachment } from './threads.js';
 export declare function initDiscord(cfg: Config): Promise<boolean>;
 export declare function startDiscord(): Promise<void>;
 export declare function stopDiscord(): Promise<void>;
 export declare function isDiscordSilenced(): boolean;
 export declare function getDiscordDefaultTarget(cfg: Config): string | null;
 export declare function sendDiscordProactiveMessage(target: string | number, message: string): Promise<void>;
-export declare function sendDiscordProactiveVoice(target: string | number, buffer: Buffer, format: string): Promise<void>;
+export declare function sendDiscordProactiveMessageWithAttachments(target: string | number, message: string, attachments: DiscordTextAttachment[]): Promise<void>;
+export declare function sendDiscordProactiveVoice(target: string | number, buffer: Uint8Array, format: string): Promise<void>;
+/**
+ * Send a message to a Discord thread by ID.
+ * Used by code-agent notifications to route updates to task-specific threads.
+ * Returns true if sent successfully, false if client unavailable or thread not found.
+ */
+export declare function sendToDiscordThread(threadId: string, message: string): Promise<boolean>;
+export declare function sendToDiscordThreadWithAttachments(threadId: string, message: string, attachments: DiscordTextAttachment[]): Promise<boolean>;
+/**
+ * Send a message with optional voice attachment to a Discord thread by ID.
+ * Used by cron jobs to route both text and voice output to the same thread.
+ * Returns true if sent successfully, false if client unavailable or thread not found.
+ */
+export declare function sendToDiscordThreadWithVoice(threadId: string, message: string, voiceBuffer?: Uint8Array, voiceFormat?: string): Promise<boolean>;

package/dist/channels/discord/index.js

@@ -3,6 +3,9 @@ import { onApprovalEvent } from '../../exec-approval.js';
 import { KNOWN_COMMANDS } from './types.js';
 import { handleCommand, handleIncomingMessage, handleInteraction, sendApprovalCard } from './handlers.js';
 import { splitToChunks } from './utils.js';
+import { sendToThread, sendToThreadWithAttachments, sendToThreadWithVoice } from './threads.js';
+import { registerDelegateToAgentHandler } from '../../tools/agent-delegation.js';
+import { createDiscordAgentDelegateHandler } from './delegation.js';
 let client = null;
 let config;
 let silenceUntil = null;
@@ -10,6 +13,7 @@ export async function initDiscord(cfg) {
     const discord = cfg.channels.discord;
     if (!discord?.enabled || !discord.token) {
         console.log('[discord] Disabled or no token configured');
+        registerDelegateToAgentHandler(null);
         return false;
     }
     config = cfg;
@@ -22,6 +26,7 @@ export async function initDiscord(cfg) {
         ],
         partials: [Partials.Channel],
     });
+    registerDelegateToAgentHandler(createDiscordAgentDelegateHandler(() => client));
     client.on('messageCreate', (message) => {
         if (message.author.bot)
             return;
@@ -89,6 +94,7 @@ export async function stopDiscord() {
     if (!client)
         return;
     client.destroy();
+    registerDelegateToAgentHandler(null);
     console.log('[discord] Bot stopped');
 }
 export function isDiscordSilenced() {
@@ -110,11 +116,21 @@ export function getDiscordDefaultTarget(cfg) {
     return null;
 }
 async function sendChunked(target, text) {
+    if (!text || !text.trim())
+        return;
     const chunks = splitToChunks(text, 1900);
     for (const chunk of chunks) {
         await target.send(chunk);
     }
 }
+function buildDiscordAttachments(files) {
+    return files
+        .filter(file => file.content.trim())
+        .map(file => new AttachmentBuilder(Buffer.from(file.content, 'utf-8'), {
+        name: file.name,
+        description: file.description,
+    }));
+}
 export async function sendDiscordProactiveMessage(target, message) {
     if (!client || isDiscordSilenced())
         return;
@@ -129,11 +145,33 @@ export async function sendDiscordProactiveMessage(target, message) {
         await sendChunked(user, message);
     }
 }
+export async function sendDiscordProactiveMessageWithAttachments(target, message, attachments) {
+    if (!client || isDiscordSilenced())
+        return;
+    const targetId = String(target);
+    const chunks = splitToChunks(message || '(No summary generated.)', 1900);
+    const files = buildDiscordAttachments(attachments);
+    const channel = await client.channels.fetch(targetId).catch(() => null);
+    if (channel && 'send' in channel && typeof channel.send === 'function') {
+        await channel.send({ content: chunks[0], files });
+        for (let i = 1; i < chunks.length; i++) {
+            await channel.send(chunks[i]);
+        }
+        return;
+    }
+    const user = await client.users.fetch(targetId).catch(() => null);
+    if (user) {
+        await user.send({ content: chunks[0], files });
+        for (let i = 1; i < chunks.length; i++) {
+            await user.send(chunks[i]);
+        }
+    }
+}
 export async function sendDiscordProactiveVoice(target, buffer, format) {
     if (!client || isDiscordSilenced())
         return;
     const targetId = String(target);
-    const attachment = new AttachmentBuilder(buffer, {
+    const attachment = new AttachmentBuilder(Buffer.from(buffer), {
         name: `voice.${format}`,
         description: 'Voice message',
     });
@@ -147,3 +185,28 @@ export async function sendDiscordProactiveVoice(target, buffer, format) {
         await user.send({ files: [attachment] });
     }
 }
+/**
+ * Send a message to a Discord thread by ID.
+ * Used by code-agent notifications to route updates to task-specific threads.
+ * Returns true if sent successfully, false if client unavailable or thread not found.
+ */
+export async function sendToDiscordThread(threadId, message) {
+    if (!client)
+        return false;
+    return sendToThread(client, threadId, message);
+}
+export async function sendToDiscordThreadWithAttachments(threadId, message, attachments) {
+    if (!client)
+        return false;
+    return sendToThreadWithAttachments(client, threadId, message, attachments);
+}
+/**
+ * Send a message with optional voice attachment to a Discord thread by ID.
+ * Used by cron jobs to route both text and voice output to the same thread.
+ * Returns true if sent successfully, false if client unavailable or thread not found.
+ */
+export async function sendToDiscordThreadWithVoice(threadId, message, voiceBuffer, voiceFormat) {
+    if (!client)
+        return false;
+    return sendToThreadWithVoice(client, threadId, message, voiceBuffer, voiceFormat);
+}

package/dist/channels/discord/thread-agents.d.ts

@@ -0,0 +1,54 @@
+import type { ThinkingLevel } from '../../types.js';
+export interface DiscordAgentProfile {
+    alias: string;
+    agentId: string;
+    model?: string;
+    thinking?: ThinkingLevel;
+    promptOverlay?: string;
+    createdBy: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface DiscordThreadAgentBinding {
+    threadId: string;
+    profileAlias: string;
+    guildId?: string;
+    channelId?: string;
+    createdBy: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface DiscordThreadAgent extends DiscordAgentProfile {
+    threadId: string;
+    guildId?: string;
+    channelId?: string;
+    profileAlias: string;
+}
+export interface DiscordAgentMentionInvocation {
+    alias: string;
+    prompt: string;
+}
+export declare function normalizeThreadAgentAlias(value: string | undefined): string | null;
+export declare function parseDiscordAgentMention(value: string): DiscordAgentMentionInvocation | null;
+export declare function listAgentProfiles(): DiscordAgentProfile[];
+export declare function listThreadAgentBindings(): DiscordThreadAgentBinding[];
+export declare function getAgentProfileByAlias(alias: string | undefined): DiscordAgentProfile | null;
+export declare function getThreadAgentByThreadId(threadId: string | undefined): DiscordThreadAgent | null;
+export declare function getThreadAgentBinding(threadId: string | undefined): DiscordThreadAgentBinding | null;
+export declare function upsertAgentProfile(input: {
+    alias: string;
+    agentId: string;
+    createdBy: string;
+}): DiscordAgentProfile;
+export declare function bindThreadAgent(input: {
+    threadId: string;
+    alias: string;
+    createdBy: string;
+    guildId?: string | null;
+    channelId?: string | null;
+}): DiscordThreadAgent;
+export declare function setAgentProfilePrompt(alias: string, promptOverlay: string | undefined): DiscordAgentProfile | null;
+export declare function setAgentProfileModel(alias: string, model: string | undefined): DiscordAgentProfile | null;
+export declare function setAgentProfileThinking(alias: string, thinking: ThinkingLevel | undefined): DiscordAgentProfile | null;
+export declare function removeAgentProfile(alias: string): boolean;
+export declare function _setThreadAgentStorePathForTesting(path: string | null): void;

package/dist/channels/discord/thread-agents.js

@@ -0,0 +1,323 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+const DEFAULT_STORE_PATH = join(homedir(), '.skimpyclaw', 'discord-thread-agents.json');
+const ALIAS_RE = /^[a-z][a-z0-9_-]{0,63}$/;
+const THINKING_LEVELS = new Set(['none', 'low', 'medium', 'high', 'xhigh']);
+let storePathOverride = null;
+let loaded = false;
+const profilesByAlias = new Map();
+const bindingsByThreadId = new Map();
+function getStorePath() {
+    return storePathOverride || DEFAULT_STORE_PATH;
+}
+export function normalizeThreadAgentAlias(value) {
+    const normalized = (value || '').trim().replace(/^@/, '').toLowerCase();
+    if (!ALIAS_RE.test(normalized))
+        return null;
+    return normalized;
+}
+export function parseDiscordAgentMention(value) {
+    const match = value.trim().match(/^@([a-z][a-z0-9_-]{0,63})(?:\s+([\s\S]*))?$/i);
+    if (!match)
+        return null;
+    const alias = normalizeThreadAgentAlias(match[1]);
+    if (!alias)
+        return null;
+    return {
+        alias,
+        prompt: (match[2] || '').trim(),
+    };
+}
+function normalizeThinking(value) {
+    return typeof value === 'string' && THINKING_LEVELS.has(value)
+        ? value
+        : undefined;
+}
+function normalizeProfile(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const raw = value;
+    const alias = normalizeThreadAgentAlias(raw.alias);
+    const agentId = typeof raw.agentId === 'string' ? raw.agentId.trim() : '';
+    const createdBy = typeof raw.createdBy === 'string' ? raw.createdBy.trim() : '';
+    const createdAt = typeof raw.createdAt === 'string' ? raw.createdAt : new Date().toISOString();
+    const updatedAt = typeof raw.updatedAt === 'string' ? raw.updatedAt : createdAt;
+    if (!alias || !agentId || !createdBy)
+        return null;
+    return {
+        alias,
+        agentId,
+        model: typeof raw.model === 'string' && raw.model.trim() ? raw.model.trim() : undefined,
+        thinking: normalizeThinking(raw.thinking),
+        promptOverlay: typeof raw.promptOverlay === 'string' && raw.promptOverlay.trim()
+            ? raw.promptOverlay.trim()
+            : undefined,
+        createdBy,
+        createdAt,
+        updatedAt,
+    };
+}
+function normalizeBinding(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const raw = value;
+    const threadId = typeof raw.threadId === 'string' ? raw.threadId.trim() : '';
+    const profileAlias = normalizeThreadAgentAlias(raw.profileAlias);
+    const createdBy = typeof raw.createdBy === 'string' ? raw.createdBy.trim() : '';
+    const createdAt = typeof raw.createdAt === 'string' ? raw.createdAt : new Date().toISOString();
+    const updatedAt = typeof raw.updatedAt === 'string' ? raw.updatedAt : createdAt;
+    if (!threadId || !profileAlias || !createdBy)
+        return null;
+    return {
+        threadId,
+        profileAlias,
+        guildId: typeof raw.guildId === 'string' && raw.guildId.trim() ? raw.guildId.trim() : undefined,
+        channelId: typeof raw.channelId === 'string' && raw.channelId.trim() ? raw.channelId.trim() : undefined,
+        createdBy,
+        createdAt,
+        updatedAt,
+    };
+}
+function normalizeLegacyRecord(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const raw = value;
+    const alias = normalizeThreadAgentAlias(raw.alias);
+    const threadId = typeof raw.threadId === 'string' ? raw.threadId.trim() : '';
+    const agentId = typeof raw.agentId === 'string' ? raw.agentId.trim() : '';
+    const createdBy = typeof raw.createdBy === 'string' ? raw.createdBy.trim() : '';
+    const createdAt = typeof raw.createdAt === 'string' ? raw.createdAt : new Date().toISOString();
+    const updatedAt = typeof raw.updatedAt === 'string' ? raw.updatedAt : createdAt;
+    if (!alias || !threadId || !agentId || !createdBy)
+        return null;
+    return {
+        profile: {
+            alias,
+            agentId,
+            model: typeof raw.model === 'string' && raw.model.trim() ? raw.model.trim() : undefined,
+            thinking: normalizeThinking(raw.thinking),
+            promptOverlay: typeof raw.promptOverlay === 'string' && raw.promptOverlay.trim()
+                ? raw.promptOverlay.trim()
+                : undefined,
+            createdBy,
+            createdAt,
+            updatedAt,
+        },
+        binding: {
+            threadId,
+            profileAlias: alias,
+            guildId: typeof raw.guildId === 'string' && raw.guildId.trim() ? raw.guildId.trim() : undefined,
+            channelId: typeof raw.channelId === 'string' && raw.channelId.trim() ? raw.channelId.trim() : undefined,
+            createdBy,
+            createdAt,
+            updatedAt,
+        },
+    };
+}
+function resolveBinding(binding) {
+    if (!binding)
+        return null;
+    const profile = profilesByAlias.get(binding.profileAlias);
+    if (!profile)
+        return null;
+    return {
+        ...profile,
+        threadId: binding.threadId,
+        profileAlias: binding.profileAlias,
+        guildId: binding.guildId,
+        channelId: binding.channelId,
+    };
+}
+function ensureLoaded() {
+    if (loaded)
+        return;
+    loaded = true;
+    const storePath = getStorePath();
+    if (!existsSync(storePath))
+        return;
+    try {
+        const parsed = JSON.parse(readFileSync(storePath, 'utf-8'));
+        if (Array.isArray(parsed)) {
+            for (const entry of parsed) {
+                const normalized = normalizeLegacyRecord(entry);
+                if (!normalized)
+                    continue;
+                profilesByAlias.set(normalized.profile.alias, normalized.profile);
+                bindingsByThreadId.set(normalized.binding.threadId, normalized.binding);
+            }
+            return;
+        }
+        const profiles = Array.isArray(parsed?.profiles) ? parsed.profiles : [];
+        const bindings = Array.isArray(parsed?.bindings) ? parsed.bindings : [];
+        for (const entry of profiles) {
+            const normalized = normalizeProfile(entry);
+            if (normalized)
+                profilesByAlias.set(normalized.alias, normalized);
+        }
+        for (const entry of bindings) {
+            const normalized = normalizeBinding(entry);
+            if (normalized)
+                bindingsByThreadId.set(normalized.threadId, normalized);
+        }
+    }
+    catch (err) {
+        console.error('[discord-thread-agents] Failed to load store:', err);
+    }
+}
+function persist() {
+    try {
+        const storePath = getStorePath();
+        mkdirSync(dirname(storePath), { recursive: true });
+        const store = {
+            version: 2,
+            profiles: listAgentProfiles(),
+            bindings: listThreadAgentBindings(),
+        };
+        writeFileSync(storePath, JSON.stringify(store, null, 2), { encoding: 'utf-8', mode: 0o600 });
+        chmodSync(storePath, 0o600);
+    }
+    catch (err) {
+        console.error('[discord-thread-agents] Failed to persist store:', err);
+    }
+}
+export function listAgentProfiles() {
+    ensureLoaded();
+    return Array.from(profilesByAlias.values()).sort((a, b) => a.alias.localeCompare(b.alias));
+}
+export function listThreadAgentBindings() {
+    ensureLoaded();
+    return Array.from(bindingsByThreadId.values()).sort((a, b) => a.threadId.localeCompare(b.threadId));
+}
+export function getAgentProfileByAlias(alias) {
+    ensureLoaded();
+    const normalized = normalizeThreadAgentAlias(alias);
+    if (!normalized)
+        return null;
+    return profilesByAlias.get(normalized) || null;
+}
+export function getThreadAgentByThreadId(threadId) {
+    ensureLoaded();
+    const id = (threadId || '').trim();
+    if (!id)
+        return null;
+    return resolveBinding(bindingsByThreadId.get(id));
+}
+export function getThreadAgentBinding(threadId) {
+    ensureLoaded();
+    const id = (threadId || '').trim();
+    if (!id)
+        return null;
+    return bindingsByThreadId.get(id) || null;
+}
+export function upsertAgentProfile(input) {
+    ensureLoaded();
+    const alias = normalizeThreadAgentAlias(input.alias);
+    const agentId = input.agentId.trim();
+    const createdBy = input.createdBy.trim();
+    if (!alias)
+        throw new Error('Alias must start with a letter and use only letters, numbers, underscore, or dash.');
+    if (!agentId)
+        throw new Error('Agent ID is required.');
+    if (!createdBy)
+        throw new Error('Creator ID is required.');
+    const existing = profilesByAlias.get(alias);
+    const now = new Date().toISOString();
+    const profile = {
+        alias,
+        agentId,
+        createdBy: existing?.createdBy || createdBy,
+        createdAt: existing?.createdAt || now,
+        updatedAt: now,
+        model: existing?.model,
+        thinking: existing?.thinking,
+        promptOverlay: existing?.promptOverlay,
+    };
+    profilesByAlias.set(alias, profile);
+    persist();
+    return profile;
+}
+export function bindThreadAgent(input) {
+    ensureLoaded();
+    const threadId = input.threadId.trim();
+    const profileAlias = normalizeThreadAgentAlias(input.alias);
+    const createdBy = input.createdBy.trim();
+    if (!threadId)
+        throw new Error('Thread ID is required.');
+    if (!profileAlias)
+        throw new Error('Agent alias is required.');
+    if (!createdBy)
+        throw new Error('Creator ID is required.');
+    if (!profilesByAlias.has(profileAlias))
+        throw new Error(`Agent profile "${profileAlias}" does not exist.`);
+    const existing = bindingsByThreadId.get(threadId);
+    const now = new Date().toISOString();
+    const binding = {
+        threadId,
+        profileAlias,
+        createdBy: existing?.createdBy || createdBy,
+        createdAt: existing?.createdAt || now,
+        updatedAt: now,
+        guildId: input.guildId?.trim() || existing?.guildId,
+        channelId: input.channelId?.trim() || existing?.channelId,
+    };
+    bindingsByThreadId.set(threadId, binding);
+    persist();
+    const resolved = resolveBinding(binding);
+    if (!resolved)
+        throw new Error(`Agent profile "${profileAlias}" does not exist.`);
+    return resolved;
+}
+export function setAgentProfilePrompt(alias, promptOverlay) {
+    ensureLoaded();
+    const profile = getAgentProfileByAlias(alias);
+    if (!profile)
+        return null;
+    const nextPrompt = promptOverlay?.trim();
+    profile.promptOverlay = nextPrompt || undefined;
+    profile.updatedAt = new Date().toISOString();
+    persist();
+    return profile;
+}
+export function setAgentProfileModel(alias, model) {
+    ensureLoaded();
+    const profile = getAgentProfileByAlias(alias);
+    if (!profile)
+        return null;
+    const nextModel = model?.trim();
+    profile.model = nextModel || undefined;
+    profile.updatedAt = new Date().toISOString();
+    persist();
+    return profile;
+}
+export function setAgentProfileThinking(alias, thinking) {
+    ensureLoaded();
+    const profile = getAgentProfileByAlias(alias);
+    if (!profile)
+        return null;
+    profile.thinking = thinking;
+    profile.updatedAt = new Date().toISOString();
+    persist();
+    return profile;
+}
+export function removeAgentProfile(alias) {
+    ensureLoaded();
+    const normalized = normalizeThreadAgentAlias(alias);
+    if (!normalized)
+        return false;
+    const deleted = profilesByAlias.delete(normalized);
+    if (deleted) {
+        for (const [threadId, binding] of bindingsByThreadId) {
+            if (binding.profileAlias === normalized)
+                bindingsByThreadId.delete(threadId);
+        }
+        persist();
+    }
+    return deleted;
+}
+export function _setThreadAgentStorePathForTesting(path) {
+    storePathOverride = path;
+    profilesByAlias.clear();
+    bindingsByThreadId.clear();
+    loaded = false;
+}

package/dist/channels/discord/threads.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Discord thread management for coding agent task updates.
+ *
+ * Creates threads from triggering messages and routes status updates
+ * to those threads instead of the main channel.
+ */
+import { type Client, type Message } from 'discord.js';
+export interface DiscordTextAttachment {
+    name: string;
+    content: string;
+    description?: string;
+}
+/**
+ * Detect if a response contains a coding agent start message.
+ * Returns the task ID if found, null otherwise.
+ */
+export declare function detectCodeAgentStart(response: string): string | null;
+/**
+ * Create a thread from the user's message for a coding agent task.
+ * Returns the thread ID, or null if thread creation fails.
+ */
+export declare function createTaskThread(message: Message, taskId: string, taskPreview: string): Promise<string | null>;
+/**
+ * Build a user-facing Discord URL for a thread, suitable for posting as a clickable link.
+ * Returns undefined if we can't construct one (e.g. missing guild context).
+ */
+export declare function buildThreadUrl(guildId: string | null | undefined, threadId: string): string | undefined;
+/**
+ * Register an existing thread for a task (e.g. restored from disk).
+ */
+export declare function registerTaskThread(taskId: string, threadId: string): void;
+/**
+ * Get the thread ID for a task, if one exists.
+ */
+export declare function getTaskThreadId(taskId: string): string | undefined;
+/**
+ * Send a message to a Discord thread. Handles chunking for long messages.
+ * Returns true if sent successfully.
+ */
+export declare function sendToThread(client: Client, threadId: string, text: string): Promise<boolean>;
+/**
+ * Send text plus one or more UTF-8 attachments to a Discord thread.
+ * Keeps the visible message compact while preserving full reports.
+ */
+export declare function sendToThreadWithAttachments(client: Client, threadId: string, text: string, attachments?: DiscordTextAttachment[]): Promise<boolean>;
+/**
+ * Send a message with optional voice attachment to a Discord thread.
+ * Handles chunking for long text messages.
+ * Returns true if sent successfully.
+ */
+export declare function sendToThreadWithVoice(client: Client, threadId: string, text: string, voiceBuffer?: Uint8Array, voiceFormat?: string): Promise<boolean>;
+/**
+ * Clean up thread mapping for a task (e.g. after completion).
+ * We keep the mapping around for a while since late notifications may arrive.
+ */
+export declare function clearTaskThread(taskId: string): void;
+/** Export for testing. */
+export declare function _getTaskThreadsMap(): Map<string, string>;