kimaki 0.4.22 → 0.4.23

package/dist/message-formatting.js

@@ -0,0 +1,188 @@
+import { createLogger } from './logger.js';
+const logger = createLogger('FORMATTING');
+export const TEXT_MIME_TYPES = [
+    'text/',
+    'application/json',
+    'application/xml',
+    'application/javascript',
+    'application/typescript',
+    'application/x-yaml',
+    'application/toml',
+];
+export function isTextMimeType(contentType) {
+    if (!contentType) {
+        return false;
+    }
+    return TEXT_MIME_TYPES.some((prefix) => contentType.startsWith(prefix));
+}
+export async function getTextAttachments(message) {
+    const textAttachments = Array.from(message.attachments.values()).filter((attachment) => isTextMimeType(attachment.contentType));
+    if (textAttachments.length === 0) {
+        return '';
+    }
+    const textContents = await Promise.all(textAttachments.map(async (attachment) => {
+        try {
+            const response = await fetch(attachment.url);
+            if (!response.ok) {
+                return `<attachment filename="${attachment.name}" error="Failed to fetch: ${response.status}" />`;
+            }
+            const text = await response.text();
+            return `<attachment filename="${attachment.name}" mime="${attachment.contentType}">\n${text}\n</attachment>`;
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            return `<attachment filename="${attachment.name}" error="${errMsg}" />`;
+        }
+    }));
+    return textContents.join('\n\n');
+}
+export function getFileAttachments(message) {
+    const fileAttachments = Array.from(message.attachments.values()).filter((attachment) => {
+        const contentType = attachment.contentType || '';
+        return (contentType.startsWith('image/') || contentType === 'application/pdf');
+    });
+    return fileAttachments.map((attachment) => ({
+        type: 'file',
+        mime: attachment.contentType || 'application/octet-stream',
+        filename: attachment.name,
+        url: attachment.url,
+    }));
+}
+export function getToolSummaryText(part) {
+    if (part.type !== 'tool')
+        return '';
+    if (part.tool === 'edit') {
+        const filePath = part.state.input?.filePath || '';
+        const newString = part.state.input?.newString || '';
+        const oldString = part.state.input?.oldString || '';
+        const added = newString.split('\n').length;
+        const removed = oldString.split('\n').length;
+        const fileName = filePath.split('/').pop() || '';
+        return fileName ? `*${fileName}* (+${added}-${removed})` : `(+${added}-${removed})`;
+    }
+    if (part.tool === 'write') {
+        const filePath = part.state.input?.filePath || '';
+        const content = part.state.input?.content || '';
+        const lines = content.split('\n').length;
+        const fileName = filePath.split('/').pop() || '';
+        return fileName ? `*${fileName}* (${lines} line${lines === 1 ? '' : 's'})` : `(${lines} line${lines === 1 ? '' : 's'})`;
+    }
+    if (part.tool === 'webfetch') {
+        const url = part.state.input?.url || '';
+        const urlWithoutProtocol = url.replace(/^https?:\/\//, '');
+        return urlWithoutProtocol ? `*${urlWithoutProtocol}*` : '';
+    }
+    if (part.tool === 'read') {
+        const filePath = part.state.input?.filePath || '';
+        const fileName = filePath.split('/').pop() || '';
+        return fileName ? `*${fileName}*` : '';
+    }
+    if (part.tool === 'list') {
+        const path = part.state.input?.path || '';
+        const dirName = path.split('/').pop() || path;
+        return dirName ? `*${dirName}*` : '';
+    }
+    if (part.tool === 'glob') {
+        const pattern = part.state.input?.pattern || '';
+        return pattern ? `*${pattern}*` : '';
+    }
+    if (part.tool === 'grep') {
+        const pattern = part.state.input?.pattern || '';
+        return pattern ? `*${pattern}*` : '';
+    }
+    if (part.tool === 'bash' || part.tool === 'todoread' || part.tool === 'todowrite') {
+        return '';
+    }
+    if (part.tool === 'task') {
+        const description = part.state.input?.description || '';
+        return description ? `_${description}_` : '';
+    }
+    if (part.tool === 'skill') {
+        const name = part.state.input?.name || '';
+        return name ? `_${name}_` : '';
+    }
+    if (!part.state.input)
+        return '';
+    const inputFields = Object.entries(part.state.input)
+        .map(([key, value]) => {
+        if (value === null || value === undefined)
+            return null;
+        const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+        const truncatedValue = stringValue.length > 300 ? stringValue.slice(0, 300) + '…' : stringValue;
+        return `${key}: ${truncatedValue}`;
+    })
+        .filter(Boolean);
+    if (inputFields.length === 0)
+        return '';
+    return `(${inputFields.join(', ')})`;
+}
+export function formatTodoList(part) {
+    if (part.type !== 'tool' || part.tool !== 'todowrite')
+        return '';
+    const todos = part.state.input?.todos || [];
+    const activeIndex = todos.findIndex((todo) => {
+        return todo.status === 'in_progress';
+    });
+    const activeTodo = todos[activeIndex];
+    if (activeIndex === -1 || !activeTodo)
+        return '';
+    return `${activeIndex + 1}. **${activeTodo.content}**`;
+}
+export function formatPart(part) {
+    if (part.type === 'text') {
+        return part.text || '';
+    }
+    if (part.type === 'reasoning') {
+        if (!part.text?.trim())
+            return '';
+        return `◼︎ thinking`;
+    }
+    if (part.type === 'file') {
+        return `📄 ${part.filename || 'File'}`;
+    }
+    if (part.type === 'step-start' || part.type === 'step-finish' || part.type === 'patch') {
+        return '';
+    }
+    if (part.type === 'agent') {
+        return `◼︎ agent ${part.id}`;
+    }
+    if (part.type === 'snapshot') {
+        return `◼︎ snapshot ${part.snapshot}`;
+    }
+    if (part.type === 'tool') {
+        if (part.tool === 'todowrite') {
+            return formatTodoList(part);
+        }
+        if (part.state.status === 'pending') {
+            return '';
+        }
+        const summaryText = getToolSummaryText(part);
+        const stateTitle = 'title' in part.state ? part.state.title : undefined;
+        let toolTitle = '';
+        if (part.state.status === 'error') {
+            toolTitle = part.state.error || 'error';
+        }
+        else if (part.tool === 'bash') {
+            const command = part.state.input?.command || '';
+            const description = part.state.input?.description || '';
+            const isSingleLine = !command.includes('\n');
+            const hasUnderscores = command.includes('_');
+            if (isSingleLine && !hasUnderscores && command.length <= 50) {
+                toolTitle = `_${command}_`;
+            }
+            else if (description) {
+                toolTitle = `_${description}_`;
+            }
+            else if (stateTitle) {
+                toolTitle = `_${stateTitle}_`;
+            }
+        }
+        else if (stateTitle) {
+            toolTitle = `_${stateTitle}_`;
+        }
+        const icon = part.state.status === 'error' ? '⨯' : '◼︎';
+        return `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
+    }
+    logger.warn('Unknown part type:', part);
+    return '';
+}

package/dist/model-command.js

@@ -0,0 +1,293 @@
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, } from 'discord.js';
+import crypto from 'node:crypto';
+import { getDatabase, setChannelModel, setSessionModel, runModelMigrations } from './database.js';
+import { initializeOpencodeForDirectory } from './opencode.js';
+import { resolveTextChannel, getKimakiMetadata } from './discord-utils.js';
+import { createLogger } from './logger.js';
+const modelLogger = createLogger('MODEL');
+// Store context by hash to avoid customId length limits (Discord max: 100 chars)
+const pendingModelContexts = new Map();
+/**
+ * Handle the /model slash command.
+ * Shows a select menu with available providers.
+ */
+export async function handleModelCommand({ interaction, appId, }) {
+    modelLogger.log('[MODEL] handleModelCommand called');
+    // Defer reply immediately to avoid 3-second timeout
+    await interaction.deferReply({ ephemeral: true });
+    modelLogger.log('[MODEL] Deferred reply');
+    // Ensure migrations are run
+    runModelMigrations();
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.editReply({
+            content: 'This command can only be used in a channel',
+        });
+        return;
+    }
+    // Determine if we're in a thread or text channel
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    let projectDirectory;
+    let channelAppId;
+    let targetChannelId;
+    let sessionId;
+    if (isThread) {
+        const thread = channel;
+        const textChannel = await resolveTextChannel(thread);
+        const metadata = getKimakiMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+        targetChannelId = textChannel?.id || channel.id;
+        // Get session ID for this thread
+        const row = getDatabase()
+            .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+            .get(thread.id);
+        sessionId = row?.session_id;
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        const textChannel = channel;
+        const metadata = getKimakiMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+        targetChannelId = channel.id;
+    }
+    else {
+        await interaction.editReply({
+            content: 'This command can only be used in text channels or threads',
+        });
+        return;
+    }
+    if (channelAppId && channelAppId !== appId) {
+        await interaction.editReply({
+            content: 'This channel is not configured for this bot',
+        });
+        return;
+    }
+    if (!projectDirectory) {
+        await interaction.editReply({
+            content: 'This channel is not configured with a project directory',
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        const providersResponse = await getClient().provider.list({
+            query: { directory: projectDirectory },
+        });
+        if (!providersResponse.data) {
+            await interaction.editReply({
+                content: 'Failed to fetch providers',
+            });
+            return;
+        }
+        const { all: allProviders, connected } = providersResponse.data;
+        // Filter to only connected providers (have credentials)
+        const availableProviders = allProviders.filter((p) => {
+            return connected.includes(p.id);
+        });
+        if (availableProviders.length === 0) {
+            await interaction.editReply({
+                content: 'No providers with credentials found. Use `/connect` in OpenCode TUI to add provider credentials.',
+            });
+            return;
+        }
+        // Store context with a short hash key to avoid customId length limits
+        const context = {
+            dir: projectDirectory,
+            channelId: targetChannelId,
+            sessionId: sessionId,
+            isThread: isThread,
+        };
+        const contextHash = crypto.randomBytes(8).toString('hex');
+        pendingModelContexts.set(contextHash, context);
+        const options = availableProviders.slice(0, 25).map((provider) => {
+            const modelCount = Object.keys(provider.models || {}).length;
+            return {
+                label: provider.name.slice(0, 100),
+                value: provider.id,
+                description: `${modelCount} model${modelCount !== 1 ? 's' : ''} available`.slice(0, 100),
+            };
+        });
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`model_provider:${contextHash}`)
+            .setPlaceholder('Select a provider')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: '**Set Model Preference**\nSelect a provider:',
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        modelLogger.error('Error loading providers:', error);
+        await interaction.editReply({
+            content: `Failed to load providers: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}
+/**
+ * Handle the provider select menu interaction.
+ * Shows a second select menu with models for the chosen provider.
+ */
+export async function handleProviderSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('model_provider:')) {
+        return;
+    }
+    // Defer update immediately to avoid timeout
+    await interaction.deferUpdate();
+    const contextHash = customId.replace('model_provider:', '');
+    const context = pendingModelContexts.get(contextHash);
+    if (!context) {
+        await interaction.editReply({
+            content: 'Selection expired. Please run /model again.',
+            components: [],
+        });
+        return;
+    }
+    const selectedProviderId = interaction.values[0];
+    if (!selectedProviderId) {
+        await interaction.editReply({
+            content: 'No provider selected',
+            components: [],
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        const providersResponse = await getClient().provider.list({
+            query: { directory: context.dir },
+        });
+        if (!providersResponse.data) {
+            await interaction.editReply({
+                content: 'Failed to fetch providers',
+                components: [],
+            });
+            return;
+        }
+        const provider = providersResponse.data.all.find((p) => p.id === selectedProviderId);
+        if (!provider) {
+            await interaction.editReply({
+                content: 'Provider not found',
+                components: [],
+            });
+            return;
+        }
+        const models = Object.entries(provider.models || {})
+            .map(([modelId, model]) => ({
+            id: modelId,
+            name: model.name,
+            releaseDate: model.release_date,
+        }))
+            // Sort by release date descending (most recent first)
+            .sort((a, b) => {
+            const dateA = a.releaseDate ? new Date(a.releaseDate).getTime() : 0;
+            const dateB = b.releaseDate ? new Date(b.releaseDate).getTime() : 0;
+            return dateB - dateA;
+        });
+        if (models.length === 0) {
+            await interaction.editReply({
+                content: `No models available for ${provider.name}`,
+                components: [],
+            });
+            return;
+        }
+        // Take first 25 models (most recent since sorted descending)
+        const recentModels = models.slice(0, 25);
+        // Update context with provider info and reuse the same hash
+        context.providerId = selectedProviderId;
+        context.providerName = provider.name;
+        pendingModelContexts.set(contextHash, context);
+        const options = recentModels.map((model) => {
+            const dateStr = model.releaseDate
+                ? new Date(model.releaseDate).toLocaleDateString()
+                : 'Unknown date';
+            return {
+                label: model.name.slice(0, 100),
+                value: model.id,
+                description: dateStr.slice(0, 100),
+            };
+        });
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`model_select:${contextHash}`)
+            .setPlaceholder('Select a model')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: `**Set Model Preference**\nProvider: **${provider.name}**\nSelect a model:`,
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        modelLogger.error('Error loading models:', error);
+        await interaction.editReply({
+            content: `Failed to load models: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
+        });
+    }
+}
+/**
+ * Handle the model select menu interaction.
+ * Stores the model preference in the database.
+ */
+export async function handleModelSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('model_select:')) {
+        return;
+    }
+    // Defer update immediately
+    await interaction.deferUpdate();
+    const contextHash = customId.replace('model_select:', '');
+    const context = pendingModelContexts.get(contextHash);
+    if (!context || !context.providerId || !context.providerName) {
+        await interaction.editReply({
+            content: 'Selection expired. Please run /model again.',
+            components: [],
+        });
+        return;
+    }
+    const selectedModelId = interaction.values[0];
+    if (!selectedModelId) {
+        await interaction.editReply({
+            content: 'No model selected',
+            components: [],
+        });
+        return;
+    }
+    // Build full model ID: provider_id/model_id
+    const fullModelId = `${context.providerId}/${selectedModelId}`;
+    try {
+        // Store in appropriate table based on context
+        if (context.isThread && context.sessionId) {
+            // Store for session
+            setSessionModel(context.sessionId, fullModelId);
+            modelLogger.log(`Set model ${fullModelId} for session ${context.sessionId}`);
+            await interaction.editReply({
+                content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\``,
+                components: [],
+            });
+        }
+        else {
+            // Store for channel
+            setChannelModel(context.channelId, fullModelId);
+            modelLogger.log(`Set model ${fullModelId} for channel ${context.channelId}`);
+            await interaction.editReply({
+                content: `Model preference set for this channel:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\`\n\nAll new sessions in this channel will use this model.`,
+                components: [],
+            });
+        }
+        // Clean up the context from memory
+        pendingModelContexts.delete(contextHash);
+    }
+    catch (error) {
+        modelLogger.error('Error saving model preference:', error);
+        await interaction.editReply({
+            content: `Failed to save model preference: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
+        });
+    }
+}

package/dist/opencode.js

@@ -0,0 +1,135 @@
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+import { createOpencodeClient, } from '@opencode-ai/sdk';
+import { createLogger } from './logger.js';
+const opencodeLogger = createLogger('OPENCODE');
+const opencodeServers = new Map();
+const serverRetryCount = new Map();
+async function getOpenPort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(0, () => {
+            const address = server.address();
+            if (address && typeof address === 'object') {
+                const port = address.port;
+                server.close(() => {
+                    resolve(port);
+                });
+            }
+            else {
+                reject(new Error('Failed to get port'));
+            }
+        });
+        server.on('error', reject);
+    });
+}
+async function waitForServer(port, maxAttempts = 30) {
+    for (let i = 0; i < maxAttempts; i++) {
+        try {
+            const endpoints = [
+                `http://localhost:${port}/api/health`,
+                `http://localhost:${port}/`,
+                `http://localhost:${port}/api`,
+            ];
+            for (const endpoint of endpoints) {
+                try {
+                    const response = await fetch(endpoint);
+                    if (response.status < 500) {
+                        opencodeLogger.log(`Server ready on port `);
+                        return true;
+                    }
+                }
+                catch (e) { }
+            }
+        }
+        catch (e) { }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    throw new Error(`Server did not start on port ${port} after ${maxAttempts} seconds`);
+}
+export async function initializeOpencodeForDirectory(directory) {
+    const existing = opencodeServers.get(directory);
+    if (existing && !existing.process.killed) {
+        opencodeLogger.log(`Reusing existing server on port ${existing.port} for directory: ${directory}`);
+        return () => {
+            const entry = opencodeServers.get(directory);
+            if (!entry?.client) {
+                throw new Error(`OpenCode server for directory "${directory}" is in an error state (no client available)`);
+            }
+            return entry.client;
+        };
+    }
+    const port = await getOpenPort();
+    const opencodeCommand = process.env.OPENCODE_PATH || 'opencode';
+    const serverProcess = spawn(opencodeCommand, ['serve', '--port', port.toString()], {
+        stdio: 'pipe',
+        detached: false,
+        cwd: directory,
+        env: {
+            ...process.env,
+            OPENCODE_CONFIG_CONTENT: JSON.stringify({
+                $schema: 'https://opencode.ai/config.json',
+                lsp: false,
+                formatter: false,
+                permission: {
+                    edit: 'allow',
+                    bash: 'allow',
+                    webfetch: 'allow',
+                },
+            }),
+            OPENCODE_PORT: port.toString(),
+        },
+    });
+    serverProcess.stdout?.on('data', (data) => {
+        opencodeLogger.log(`opencode ${directory}: ${data.toString().trim()}`);
+    });
+    serverProcess.stderr?.on('data', (data) => {
+        opencodeLogger.error(`opencode ${directory}: ${data.toString().trim()}`);
+    });
+    serverProcess.on('error', (error) => {
+        opencodeLogger.error(`Failed to start server on port :`, port, error);
+    });
+    serverProcess.on('exit', (code) => {
+        opencodeLogger.log(`Opencode server on ${directory} exited with code:`, code);
+        opencodeServers.delete(directory);
+        if (code !== 0) {
+            const retryCount = serverRetryCount.get(directory) || 0;
+            if (retryCount < 5) {
+                serverRetryCount.set(directory, retryCount + 1);
+                opencodeLogger.log(`Restarting server for directory: ${directory} (attempt ${retryCount + 1}/5)`);
+                initializeOpencodeForDirectory(directory).catch((e) => {
+                    opencodeLogger.error(`Failed to restart opencode server:`, e);
+                });
+            }
+            else {
+                opencodeLogger.error(`Server for ${directory} crashed too many times (5), not restarting`);
+            }
+        }
+        else {
+            serverRetryCount.delete(directory);
+        }
+    });
+    await waitForServer(port);
+    const client = createOpencodeClient({
+        baseUrl: `http://localhost:${port}`,
+        fetch: (request) => fetch(request, {
+            // @ts-ignore
+            timeout: false,
+        }),
+    });
+    opencodeServers.set(directory, {
+        process: serverProcess,
+        client,
+        port,
+    });
+    return () => {
+        const entry = opencodeServers.get(directory);
+        if (!entry?.client) {
+            throw new Error(`OpenCode server for directory "${directory}" is in an error state (no client available)`);
+        }
+        return entry.client;
+    };
+}
+export function getOpencodeServers() {
+    return opencodeServers;
+}