shuvmaki 0.4.26

package/dist/tools.js

@@ -0,0 +1,356 @@
+// Voice assistant tool definitions for the GenAI worker.
+// Provides tools for managing OpenCode sessions (create, submit, abort),
+// listing chats, searching files, and reading session messages.
+import { tool } from 'ai';
+import { z } from 'zod';
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+import { createOpencodeClient, } from '@opencode-ai/sdk';
+import { createLogger } from './logger.js';
+const toolsLogger = createLogger('TOOLS');
+import { ShareMarkdown } from './markdown.js';
+import { formatDistanceToNow } from './utils.js';
+import pc from 'picocolors';
+import { initializeOpencodeForDirectory, getOpencodeSystemMessage, } from './discord-bot.js';
+export async function getTools({ onMessageCompleted, directory, }) {
+    const getClient = await initializeOpencodeForDirectory(directory);
+    const client = getClient();
+    const markdownRenderer = new ShareMarkdown(client);
+    const providersResponse = await client.config.providers({});
+    const providers = providersResponse.data?.providers || [];
+    // Helper: get last assistant model for a session (non-summary)
+    const getSessionModel = async (sessionId) => {
+        const res = await getClient().session.messages({ path: { id: sessionId } });
+        const data = res.data;
+        if (!data || data.length === 0)
+            return undefined;
+        for (let i = data.length - 1; i >= 0; i--) {
+            const info = data?.[i]?.info;
+            if (info?.role === 'assistant') {
+                const ai = info;
+                if (!ai.summary && ai.providerID && ai.modelID) {
+                    return { providerID: ai.providerID, modelID: ai.modelID };
+                }
+            }
+        }
+        return undefined;
+    };
+    const tools = {
+        submitMessage: tool({
+            description: 'Submit a message to an existing chat session. Does not wait for the message to complete',
+            inputSchema: z.object({
+                sessionId: z.string().describe('The session ID to send message to'),
+                message: z.string().describe('The message text to send'),
+            }),
+            execute: async ({ sessionId, message }) => {
+                const sessionModel = await getSessionModel(sessionId);
+                // do not await
+                getClient()
+                    .session.prompt({
+                    path: { id: sessionId },
+                    body: {
+                        parts: [{ type: 'text', text: message }],
+                        model: sessionModel,
+                        system: getOpencodeSystemMessage({ sessionId }),
+                    },
+                })
+                    .then(async (response) => {
+                    const markdown = await markdownRenderer.generate({
+                        sessionID: sessionId,
+                        lastAssistantOnly: true,
+                    });
+                    onMessageCompleted?.({
+                        sessionId,
+                        messageId: '',
+                        data: response.data,
+                        markdown,
+                    });
+                })
+                    .catch((error) => {
+                    onMessageCompleted?.({
+                        sessionId,
+                        messageId: '',
+                        error,
+                    });
+                });
+                return {
+                    success: true,
+                    sessionId,
+                    directive: 'Tell user that message has been sent successfully',
+                };
+            },
+        }),
+        createNewChat: tool({
+            description: 'Start a new chat session with an initial message. Does not wait for the message to complete',
+            inputSchema: z.object({
+                message: z
+                    .string()
+                    .describe('The initial message to start the chat with'),
+                title: z.string().optional().describe('Optional title for the session'),
+                model: z
+                    .object({
+                    providerId: z
+                        .string()
+                        .describe('The provider ID (e.g., "anthropic", "openai")'),
+                    modelId: z
+                        .string()
+                        .describe('The model ID (e.g., "claude-opus-4-20250514", "gpt-5")'),
+                })
+                    .optional()
+                    .describe('Optional model to use for this session'),
+            }),
+            execute: async ({ message, title, }) => {
+                if (!message.trim()) {
+                    throw new Error(`message must be a non empty string`);
+                }
+                try {
+                    const session = await getClient().session.create({
+                        body: {
+                            title: title || message.slice(0, 50),
+                        },
+                    });
+                    if (!session.data) {
+                        throw new Error('Failed to create session');
+                    }
+                    // do not await
+                    getClient()
+                        .session.prompt({
+                        path: { id: session.data.id },
+                        body: {
+                            parts: [{ type: 'text', text: message }],
+                            system: getOpencodeSystemMessage({ sessionId: session.data.id }),
+                        },
+                    })
+                        .then(async (response) => {
+                        const markdown = await markdownRenderer.generate({
+                            sessionID: session.data.id,
+                            lastAssistantOnly: true,
+                        });
+                        onMessageCompleted?.({
+                            sessionId: session.data.id,
+                            messageId: '',
+                            data: response.data,
+                            markdown,
+                        });
+                    })
+                        .catch((error) => {
+                        onMessageCompleted?.({
+                            sessionId: session.data.id,
+                            messageId: '',
+                            error,
+                        });
+                    });
+                    return {
+                        success: true,
+                        sessionId: session.data.id,
+                        title: session.data.title,
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: false,
+                        error: error instanceof Error
+                            ? error.message
+                            : 'Failed to create chat session',
+                    };
+                }
+            },
+        }),
+        listChats: tool({
+            description: 'Get a list of available chat sessions sorted by most recent',
+            inputSchema: z.object({}),
+            execute: async () => {
+                toolsLogger.log(`Listing opencode sessions`);
+                const sessions = await getClient().session.list();
+                if (!sessions.data) {
+                    return { success: false, error: 'No sessions found' };
+                }
+                const sortedSessions = [...sessions.data]
+                    .sort((a, b) => {
+                    return b.time.updated - a.time.updated;
+                })
+                    .slice(0, 20);
+                const sessionList = sortedSessions.map(async (session) => {
+                    const finishedAt = session.time.updated;
+                    const status = await (async () => {
+                        if (session.revert)
+                            return 'error';
+                        const messagesResponse = await getClient().session.messages({
+                            path: { id: session.id },
+                        });
+                        const messages = messagesResponse.data || [];
+                        const lastMessage = messages[messages.length - 1];
+                        if (lastMessage?.info.role === 'assistant' &&
+                            !lastMessage.info.time.completed) {
+                            return 'in_progress';
+                        }
+                        return 'finished';
+                    })();
+                    return {
+                        id: session.id,
+                        folder: session.directory,
+                        status,
+                        finishedAt: formatDistanceToNow(new Date(finishedAt)),
+                        title: session.title,
+                        prompt: session.title,
+                    };
+                });
+                const resolvedList = await Promise.all(sessionList);
+                return {
+                    success: true,
+                    sessions: resolvedList,
+                };
+            },
+        }),
+        searchFiles: tool({
+            description: 'Search for files in a folder',
+            inputSchema: z.object({
+                folder: z
+                    .string()
+                    .optional()
+                    .describe('The folder path to search in, optional. only use if user specifically asks for it'),
+                query: z.string().describe('The search query for files'),
+            }),
+            execute: async ({ folder, query }) => {
+                const results = await getClient().find.files({
+                    query: {
+                        query,
+                        directory: folder,
+                    },
+                });
+                return {
+                    success: true,
+                    files: results.data || [],
+                };
+            },
+        }),
+        readSessionMessages: tool({
+            description: 'Read messages from a chat session',
+            inputSchema: z.object({
+                sessionId: z.string().describe('The session ID to read messages from'),
+                lastAssistantOnly: z
+                    .boolean()
+                    .optional()
+                    .describe('Only read the last assistant message'),
+            }),
+            execute: async ({ sessionId, lastAssistantOnly = false }) => {
+                if (lastAssistantOnly) {
+                    const messages = await getClient().session.messages({
+                        path: { id: sessionId },
+                    });
+                    if (!messages.data) {
+                        return { success: false, error: 'No messages found' };
+                    }
+                    const assistantMessages = messages.data.filter((m) => m.info.role === 'assistant');
+                    if (assistantMessages.length === 0) {
+                        return {
+                            success: false,
+                            error: 'No assistant messages found',
+                        };
+                    }
+                    const lastMessage = assistantMessages[assistantMessages.length - 1];
+                    const status = 'completed' in lastMessage.info.time &&
+                        lastMessage.info.time.completed
+                        ? 'completed'
+                        : 'in_progress';
+                    const markdown = await markdownRenderer.generate({
+                        sessionID: sessionId,
+                        lastAssistantOnly: true,
+                    });
+                    return {
+                        success: true,
+                        markdown,
+                        status,
+                    };
+                }
+                else {
+                    const markdown = await markdownRenderer.generate({
+                        sessionID: sessionId,
+                    });
+                    const messages = await getClient().session.messages({
+                        path: { id: sessionId },
+                    });
+                    const lastMessage = messages.data?.[messages.data.length - 1];
+                    const status = lastMessage?.info.role === 'assistant' &&
+                        lastMessage?.info.time &&
+                        'completed' in lastMessage.info.time &&
+                        !lastMessage.info.time.completed
+                        ? 'in_progress'
+                        : 'completed';
+                    return {
+                        success: true,
+                        markdown,
+                        status,
+                    };
+                }
+            },
+        }),
+        abortChat: tool({
+            description: 'Abort/stop an in-progress chat session',
+            inputSchema: z.object({
+                sessionId: z.string().describe('The session ID to abort'),
+            }),
+            execute: async ({ sessionId }) => {
+                try {
+                    const result = await getClient().session.abort({
+                        path: { id: sessionId },
+                    });
+                    if (!result.data) {
+                        return {
+                            success: false,
+                            error: 'Failed to abort session',
+                        };
+                    }
+                    return {
+                        success: true,
+                        sessionId,
+                        message: 'Session aborted successfully',
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error occurred',
+                    };
+                }
+            },
+        }),
+        getModels: tool({
+            description: 'Get all available AI models from all providers',
+            inputSchema: z.object({}),
+            execute: async () => {
+                try {
+                    const providersResponse = await getClient().config.providers({});
+                    const providers = providersResponse.data?.providers || [];
+                    const models = [];
+                    providers.forEach((provider) => {
+                        if (provider.models && typeof provider.models === 'object') {
+                            Object.entries(provider.models).forEach(([modelId, model]) => {
+                                models.push({
+                                    providerId: provider.id,
+                                    modelId: modelId,
+                                });
+                            });
+                        }
+                    });
+                    return {
+                        success: true,
+                        models,
+                        totalCount: models.length,
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Failed to fetch models',
+                        models: [],
+                    };
+                }
+            },
+        }),
+    };
+    return {
+        tools,
+        providers,
+    };
+}

package/dist/utils.js

@@ -0,0 +1,85 @@
+// General utility functions for the bot.
+// Includes Discord OAuth URL generation, array deduplication,
+// abort error detection, and date/time formatting helpers.
+import { PermissionsBitField } from 'discord.js';
+export function generateBotInstallUrl({ clientId, permissions = [
+    PermissionsBitField.Flags.ViewChannel,
+    PermissionsBitField.Flags.ManageChannels,
+    PermissionsBitField.Flags.SendMessages,
+    PermissionsBitField.Flags.SendMessagesInThreads,
+    PermissionsBitField.Flags.CreatePublicThreads,
+    PermissionsBitField.Flags.ManageThreads,
+    PermissionsBitField.Flags.ReadMessageHistory,
+    PermissionsBitField.Flags.AddReactions,
+    PermissionsBitField.Flags.ManageMessages,
+    PermissionsBitField.Flags.UseExternalEmojis,
+    PermissionsBitField.Flags.AttachFiles,
+    PermissionsBitField.Flags.Connect,
+    PermissionsBitField.Flags.Speak,
+], scopes = ['bot'], guildId, disableGuildSelect = false, }) {
+    const permissionsBitField = new PermissionsBitField(permissions);
+    const permissionsValue = permissionsBitField.bitfield.toString();
+    const url = new URL('https://discord.com/api/oauth2/authorize');
+    url.searchParams.set('client_id', clientId);
+    url.searchParams.set('permissions', permissionsValue);
+    url.searchParams.set('scope', scopes.join(' '));
+    if (guildId) {
+        url.searchParams.set('guild_id', guildId);
+    }
+    if (disableGuildSelect) {
+        url.searchParams.set('disable_guild_select', 'true');
+    }
+    return url.toString();
+}
+export function deduplicateByKey(arr, keyFn) {
+    const seen = new Set();
+    return arr.filter((item) => {
+        const key = keyFn(item);
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+export function isAbortError(error, signal) {
+    return ((error instanceof Error &&
+        (error.name === 'AbortError' ||
+            error.name === 'Aborterror' ||
+            error.name === 'aborterror' ||
+            error.name.toLowerCase() === 'aborterror' ||
+            error.message?.includes('aborted') ||
+            (signal?.aborted ?? false))) ||
+        (error instanceof DOMException && error.name === 'AbortError'));
+}
+const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' });
+const TIME_DIVISIONS = [
+    { amount: 60, name: 'seconds' },
+    { amount: 60, name: 'minutes' },
+    { amount: 24, name: 'hours' },
+    { amount: 7, name: 'days' },
+    { amount: 4.34524, name: 'weeks' },
+    { amount: 12, name: 'months' },
+    { amount: Number.POSITIVE_INFINITY, name: 'years' },
+];
+export function formatDistanceToNow(date) {
+    let duration = (date.getTime() - Date.now()) / 1000;
+    for (const division of TIME_DIVISIONS) {
+        if (Math.abs(duration) < division.amount) {
+            return rtf.format(Math.round(duration), division.name);
+        }
+        duration /= division.amount;
+    }
+    return rtf.format(Math.round(duration), 'years');
+}
+const dtf = new Intl.DateTimeFormat('en-US', {
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true,
+});
+export function formatDateTime(date) {
+    return dtf.format(date);
+}