kimaki 0.4.38 → 0.4.40

package/dist/database.js

@@ -4,6 +4,7 @@
 import Database from 'better-sqlite3';
 import fs from 'node:fs';
 import path from 'node:path';
+import * as errore from 'errore';
 import { createLogger } from './logger.js';
 import { getDataDir } from './config.js';
 const dbLogger = createLogger('DB');
@@ -11,11 +12,14 @@ let db = null;
 export function getDatabase() {
     if (!db) {
         const dataDir = getDataDir();
-        try {
-            fs.mkdirSync(dataDir, { recursive: true });
-        }
-        catch (error) {
-            dbLogger.error(`Failed to create data directory ${dataDir}:`, error);
+        const mkdirError = errore.tryFn({
+            try: () => {
+                fs.mkdirSync(dataDir, { recursive: true });
+            },
+            catch: (e) => e,
+        });
+        if (mkdirError instanceof Error) {
+            dbLogger.error(`Failed to create data directory ${dataDir}:`, mkdirError.message);
         }
         const dbPath = path.join(dataDir, 'discord-sessions.db');
         dbLogger.log(`Opening database at: ${dbPath}`);
@@ -71,6 +75,19 @@ export function getDatabase() {
         xai_api_key TEXT,
         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
       )
+    `);
+        // Track worktrees created for threads (for /new-worktree command)
+        // status: 'pending' while creating, 'ready' when done, 'error' if failed
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS thread_worktrees (
+        thread_id TEXT PRIMARY KEY,
+        worktree_name TEXT NOT NULL,
+        worktree_directory TEXT,
+        project_directory TEXT NOT NULL,
+        status TEXT DEFAULT 'pending',
+        error_message TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
     `);
         runModelMigrations(db);
     }
@@ -198,6 +215,41 @@ export function setSessionAgent(sessionId, agentName) {
     const db = getDatabase();
     db.prepare(`INSERT OR REPLACE INTO session_agents (session_id, agent_name) VALUES (?, ?)`).run(sessionId, agentName);
 }
+/**
+ * Get the worktree info for a thread.
+ */
+export function getThreadWorktree(threadId) {
+    const db = getDatabase();
+    return db.prepare('SELECT * FROM thread_worktrees WHERE thread_id = ?').get(threadId);
+}
+/**
+ * Create a pending worktree entry for a thread.
+ */
+export function createPendingWorktree({ threadId, worktreeName, projectDirectory, }) {
+    const db = getDatabase();
+    db.prepare(`INSERT OR REPLACE INTO thread_worktrees (thread_id, worktree_name, project_directory, status) VALUES (?, ?, ?, 'pending')`).run(threadId, worktreeName, projectDirectory);
+}
+/**
+ * Mark a worktree as ready with its directory.
+ */
+export function setWorktreeReady({ threadId, worktreeDirectory, }) {
+    const db = getDatabase();
+    db.prepare(`UPDATE thread_worktrees SET worktree_directory = ?, status = 'ready' WHERE thread_id = ?`).run(worktreeDirectory, threadId);
+}
+/**
+ * Mark a worktree as failed with error message.
+ */
+export function setWorktreeError({ threadId, errorMessage, }) {
+    const db = getDatabase();
+    db.prepare(`UPDATE thread_worktrees SET status = 'error', error_message = ? WHERE thread_id = ?`).run(errorMessage, threadId);
+}
+/**
+ * Delete the worktree info for a thread.
+ */
+export function deleteThreadWorktree(threadId) {
+    const db = getDatabase();
+    db.prepare('DELETE FROM thread_worktrees WHERE thread_id = ?').run(threadId);
+}
 export function closeDatabase() {
     if (db) {
         db.close();

package/dist/discord-bot.js

@@ -1,7 +1,7 @@
 // Core Discord bot module that handles message events and bot lifecycle.
 // Bridges Discord messages to OpenCode sessions, manages voice connections,
 // and orchestrates the main event loop for the Kimaki bot.
-import { getDatabase, closeDatabase } from './database.js';
+import { getDatabase, closeDatabase, getThreadWorktree } from './database.js';
 import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js';
 import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, SILENT_MESSAGE_FLAGS, } from './discord-utils.js';
 import { getOpencodeSystemMessage } from './system-message.js';
@@ -18,10 +18,14 @@ export { getOpencodeSystemMessage } from './system-message.js';
 export { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, getChannelsWithDescriptions, } from './channel-management.js';
 import { ChannelType, Client, Events, GatewayIntentBits, Partials, PermissionsBitField, ThreadAutoArchiveDuration, } from 'discord.js';
 import fs from 'node:fs';
+import * as errore from 'errore';
 import { extractTagsArrays } from './xml.js';
 import { createLogger } from './logger.js';
 import { setGlobalDispatcher, Agent } from 'undici';
-setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }));
+// Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
+// Each session's event.subscribe() holds a connection; without enough connections,
+// regular HTTP requests (question.reply, session.prompt) get blocked → deadlock.
+setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0, connections: 500 }));
 const discordLogger = createLogger('DISCORD');
 const voiceLogger = createLogger('VOICE');
 export async function createDiscordClient() {
@@ -89,11 +93,12 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             }
             if (message.partial) {
                 discordLogger.log(`Fetching partial message ${message.id}`);
-                try {
-                    await message.fetch();
-                }
-                catch (error) {
-                    discordLogger.log(`Failed to fetch partial message ${message.id}:`, error);
+                const fetched = await errore.tryAsync({
+                    try: () => message.fetch(),
+                    catch: (e) => e,
+                });
+                if (fetched instanceof Error) {
+                    discordLogger.log(`Failed to fetch partial message ${message.id}:`, fetched.message);
                     return;
                 }
             }
@@ -130,6 +135,28 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
                     channelAppId = extracted['kimaki.app']?.[0]?.trim();
                 }
+                // Check if this thread is a worktree thread
+                const worktreeInfo = getThreadWorktree(thread.id);
+                if (worktreeInfo) {
+                    if (worktreeInfo.status === 'pending') {
+                        await message.reply({
+                            content: '⏳ Worktree is still being created. Please wait...',
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    if (worktreeInfo.status === 'error') {
+                        await message.reply({
+                            content: `❌ Worktree creation failed: ${worktreeInfo.error_message}`,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    if (worktreeInfo.worktree_directory) {
+                        projectDirectory = worktreeInfo.worktree_directory;
+                        discordLogger.log(`Using worktree directory: ${projectDirectory}`);
+                    }
+                }
                 if (channelAppId && channelAppId !== currentAppId) {
                     voiceLogger.log(`[IGNORED] Thread belongs to different bot app (expected: ${currentAppId}, got: ${channelAppId})`);
                     return;
@@ -173,28 +200,39 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 if (projectDirectory) {
                     try {
                         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+                        if (getClient instanceof Error) {
+                            voiceLogger.error(`[SESSION] Failed to initialize OpenCode client:`, getClient.message);
+                            throw new Error(getClient.message);
+                        }
                         const client = getClient();
                         // get current session context (without system prompt, it would be duplicated)
                         if (row.session_id) {
-                            currentSessionContext = await getCompactSessionContext({
+                            const result = await getCompactSessionContext({
                                 client,
                                 sessionId: row.session_id,
                                 includeSystemPrompt: false,
                                 maxMessages: 15,
                             });
+                            if (errore.isOk(result)) {
+                                currentSessionContext = result;
+                            }
                         }
                         // get last session context (with system prompt for project context)
-                        const lastSessionId = await getLastSessionId({
+                        const lastSessionResult = await getLastSessionId({
                             client,
                             excludeSessionId: row.session_id,
                         });
+                        const lastSessionId = errore.unwrapOr(lastSessionResult, null);
                         if (lastSessionId) {
-                            lastSessionContext = await getCompactSessionContext({
+                            const result = await getCompactSessionContext({
                                 client,
                                 sessionId: lastSessionId,
                                 includeSystemPrompt: true,
                                 maxMessages: 10,
                             });
+                            if (errore.isOk(result)) {
+                                lastSessionContext = result;
+                            }
                         }
                     }
                     catch (e) {

package/dist/discord-utils.js

@@ -8,6 +8,9 @@ import { formatMarkdownTables } from './format-tables.js';
 import { limitHeadingDepth } from './limit-heading-depth.js';
 import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js';
 import { createLogger } from './logger.js';
+import mime from 'mime';
+import fs from 'node:fs';
+import path from 'node:path';
 const discordLogger = createLogger('DISCORD');
 export const SILENT_MESSAGE_FLAGS = 4 | 4096;
 // Same as SILENT but without SuppressNotifications - triggers badge/notification
@@ -244,3 +247,36 @@ export function getKimakiMetadata(textChannel) {
     const channelAppId = extracted['kimaki.app']?.[0]?.trim();
     return { projectDirectory, channelAppId };
 }
+/**
+ * Upload files to a Discord thread/channel in a single message.
+ * Sending all files in one message causes Discord to display images in a grid layout.
+ */
+export async function uploadFilesToDiscord({ threadId, botToken, files, }) {
+    if (files.length === 0) {
+        return;
+    }
+    // Build attachments array for all files
+    const attachments = files.map((file, index) => ({
+        id: index,
+        filename: path.basename(file),
+    }));
+    const formData = new FormData();
+    formData.append('payload_json', JSON.stringify({ attachments }));
+    // Append each file with its array index, with correct MIME type for grid display
+    files.forEach((file, index) => {
+        const buffer = fs.readFileSync(file);
+        const mimeType = mime.getType(file) || 'application/octet-stream';
+        formData.append(`files[${index}]`, new Blob([buffer], { type: mimeType }), path.basename(file));
+    });
+    const response = await fetch(`https://discord.com/api/v10/channels/${threadId}/messages`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bot ${botToken}`,
+        },
+        body: formData,
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Discord API error: ${response.status} - ${error}`);
+    }
+}

package/dist/errors.js

@@ -0,0 +1,109 @@
+// TaggedError definitions for type-safe error handling with errore.
+// Errors are grouped by category: infrastructure, domain, and validation.
+// Use errore.matchError() for exhaustive error handling in command handlers.
+import { createTaggedError } from 'errore';
+// ═══════════════════════════════════════════════════════════════════════════
+// INFRASTRUCTURE ERRORS - Server, filesystem, external services
+// ═══════════════════════════════════════════════════════════════════════════
+export class DirectoryNotAccessibleError extends createTaggedError({
+    name: 'DirectoryNotAccessibleError',
+    message: 'Directory does not exist or is not accessible: $directory',
+}) {
+}
+export class ServerStartError extends createTaggedError({
+    name: 'ServerStartError',
+    message: 'Server failed to start on port $port: $reason',
+}) {
+}
+export class ServerNotFoundError extends createTaggedError({
+    name: 'ServerNotFoundError',
+    message: 'OpenCode server not found for directory: $directory',
+}) {
+}
+export class ServerNotReadyError extends createTaggedError({
+    name: 'ServerNotReadyError',
+    message: 'OpenCode server for directory "$directory" is in an error state (no client available)',
+}) {
+}
+export class ApiKeyMissingError extends createTaggedError({
+    name: 'ApiKeyMissingError',
+    message: '$service API key is required',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// DOMAIN ERRORS - Sessions, messages, transcription
+// ═══════════════════════════════════════════════════════════════════════════
+export class SessionNotFoundError extends createTaggedError({
+    name: 'SessionNotFoundError',
+    message: 'Session $sessionId not found',
+}) {
+}
+export class SessionCreateError extends createTaggedError({
+    name: 'SessionCreateError',
+    message: '$message',
+}) {
+}
+export class MessagesNotFoundError extends createTaggedError({
+    name: 'MessagesNotFoundError',
+    message: 'No messages found for session $sessionId',
+}) {
+}
+export class TranscriptionError extends createTaggedError({
+    name: 'TranscriptionError',
+    message: 'Transcription failed: $reason',
+}) {
+}
+export class GrepSearchError extends createTaggedError({
+    name: 'GrepSearchError',
+    message: 'Grep search failed for pattern: $pattern',
+}) {
+}
+export class GlobSearchError extends createTaggedError({
+    name: 'GlobSearchError',
+    message: 'Glob search failed for pattern: $pattern',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// VALIDATION ERRORS - Input validation, format checks
+// ═══════════════════════════════════════════════════════════════════════════
+export class InvalidAudioFormatError extends createTaggedError({
+    name: 'InvalidAudioFormatError',
+    message: 'Invalid audio format',
+}) {
+}
+export class EmptyTranscriptionError extends createTaggedError({
+    name: 'EmptyTranscriptionError',
+    message: 'Model returned empty transcription',
+}) {
+}
+export class NoResponseContentError extends createTaggedError({
+    name: 'NoResponseContentError',
+    message: 'No response content from model',
+}) {
+}
+export class NoToolResponseError extends createTaggedError({
+    name: 'NoToolResponseError',
+    message: 'No valid tool responses',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// NETWORK ERRORS - Fetch and HTTP
+// ═══════════════════════════════════════════════════════════════════════════
+export class FetchError extends createTaggedError({
+    name: 'FetchError',
+    message: 'Fetch failed for $url',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// API ERRORS - External service responses
+// ═══════════════════════════════════════════════════════════════════════════
+export class DiscordApiError extends createTaggedError({
+    name: 'DiscordApiError',
+    message: 'Discord API error: $status $body',
+}) {
+}
+export class OpenCodeApiError extends createTaggedError({
+    name: 'OpenCodeApiError',
+    message: 'OpenCode API error ($status): $body',
+}) {
+}

package/dist/genai-worker.js

@@ -3,12 +3,13 @@
 // Resamples 24kHz GenAI output to 48kHz stereo Opus packets for Discord.
 import { parentPort, threadId } from 'node:worker_threads';
 import { createWriteStream } from 'node:fs';
-import { mkdir } from 'node:fs/promises';
 import path from 'node:path';
+import * as errore from 'errore';
 import { Resampler } from '@purinton/resampler';
 import * as prism from 'prism-media';
 import { startGenAiSession } from './genai.js';
 import { getTools } from './tools.js';
+import { mkdir } from 'node:fs/promises';
 import { createLogger } from './logger.js';
 if (!parentPort) {
     throw new Error('This module must be run as a worker thread');
@@ -98,23 +99,24 @@ async function createAssistantAudioLogStream(guildId, channelId) {
         return null;
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
     const audioDir = path.join(process.cwd(), 'discord-audio-logs', guildId, channelId);
-    try {
-        await mkdir(audioDir, { recursive: true });
-        // Create stream for assistant audio (24kHz mono s16le PCM)
-        const outputFileName = `assistant_${timestamp}.24.pcm`;
-        const outputFilePath = path.join(audioDir, outputFileName);
-        const outputAudioStream = createWriteStream(outputFilePath);
-        // Add error handler to prevent crashes
-        outputAudioStream.on('error', (error) => {
-            workerLogger.error(`Assistant audio log stream error:`, error);
-        });
-        workerLogger.log(`Created assistant audio log: ${outputFilePath}`);
-        return outputAudioStream;
-    }
-    catch (error) {
-        workerLogger.error(`Failed to create audio log directory:`, error);
+    const mkdirError = await errore.tryAsync({
+        try: () => mkdir(audioDir, { recursive: true }),
+        catch: (e) => e,
+    });
+    if (mkdirError instanceof Error) {
+        workerLogger.error(`Failed to create audio log directory:`, mkdirError.message);
         return null;
     }
+    // Create stream for assistant audio (24kHz mono s16le PCM)
+    const outputFileName = `assistant_${timestamp}.24.pcm`;
+    const outputFilePath = path.join(audioDir, outputFileName);
+    const outputAudioStream = createWriteStream(outputFilePath);
+    // Add error handler to prevent crashes
+    outputAudioStream.on('error', (error) => {
+        workerLogger.error(`Assistant audio log stream error:`, error);
+    });
+    workerLogger.log(`Created assistant audio log: ${outputFilePath}`);
+    return outputAudioStream;
 }
 // Handle encoded Opus packets
 opusEncoder.on('data', (packet) => {

package/dist/interaction-handler.js

@@ -3,6 +3,7 @@
 // and manages autocomplete, select menu interactions for the bot.
 import { Events } from 'discord.js';
 import { handleSessionCommand, handleSessionAutocomplete } from './commands/session.js';
+import { handleNewWorktreeCommand } from './commands/worktree.js';
 import { handleResumeCommand, handleResumeAutocomplete } from './commands/resume.js';
 import { handleAddProjectCommand, handleAddProjectAutocomplete } from './commands/add-project.js';
 import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './commands/remove-project.js';
@@ -30,7 +31,7 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     : 'other'}`);
             if (interaction.isAutocomplete()) {
                 switch (interaction.commandName) {
-                    case 'session':
+                    case 'new-session':
                         await handleSessionAutocomplete({ interaction, appId });
                         return;
                     case 'resume':
@@ -50,9 +51,12 @@ export function registerInteractionHandler({ discordClient, appId, }) {
             if (interaction.isChatInputCommand()) {
                 interactionLogger.log(`[COMMAND] Processing: ${interaction.commandName}`);
                 switch (interaction.commandName) {
-                    case 'session':
+                    case 'new-session':
                         await handleSessionCommand({ command: interaction, appId });
                         return;
+                    case 'new-worktree':
+                        await handleNewWorktreeCommand({ command: interaction, appId });
+                        return;
                     case 'resume':
                         await handleResumeCommand({ command: interaction, appId });
                         return;