kimaki 0.4.37 → 0.4.39

package/dist/commands/undo-redo.js

@@ -4,6 +4,7 @@ import { getDatabase } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const logger = createLogger('UNDO-REDO');
 export async function handleUndoCommand({ command }) {
     const channel = command.channel;
@@ -50,9 +51,13 @@ export async function handleUndoCommand({ command }) {
         return;
     }
     const sessionId = row.session_id;
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        await command.editReply(`Failed to undo: ${getClient.message}`);
+        return;
+    }
     try {
-        await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
-        const getClient = await initializeOpencodeForDirectory(directory);
         // Fetch messages to find the last assistant message
         const messagesResponse = await getClient().session.messages({
             path: { id: sessionId },
@@ -133,9 +138,13 @@ export async function handleRedoCommand({ command }) {
         return;
     }
     const sessionId = row.session_id;
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        await command.editReply(`Failed to redo: ${getClient.message}`);
+        return;
+    }
     try {
-        await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
-        const getClient = await initializeOpencodeForDirectory(directory);
         // Check if session has reverted state
         const sessionResponse = await getClient().session.get({
             path: { id: sessionId },

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 (errore.isError(mkdirError)) {
+            dbLogger.error(`Failed to create data directory ${dataDir}:`, mkdirError.message);
         }
         const dbPath = path.join(dataDir, 'discord-sessions.db');
         dbLogger.log(`Opening database at: ${dbPath}`);
@@ -57,6 +61,13 @@ export function getDatabase() {
         catch {
             // Column already exists, ignore
         }
+        // Table for threads that should auto-start a session (created by CLI without --notify-only)
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS pending_auto_start (
+        thread_id TEXT PRIMARY KEY,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
         db.exec(`
       CREATE TABLE IF NOT EXISTS bot_api_keys (
         app_id TEXT PRIMARY KEY,
@@ -147,6 +158,14 @@ export function setSessionModel(sessionId, modelId) {
     const db = getDatabase();
     db.prepare(`INSERT OR REPLACE INTO session_models (session_id, model_id) VALUES (?, ?)`).run(sessionId, modelId);
 }
+/**
+ * Clear the model preference for a session.
+ * Used when switching agents so the agent's model takes effect.
+ */
+export function clearSessionModel(sessionId) {
+    const db = getDatabase();
+    db.prepare('DELETE FROM session_models WHERE session_id = ?').run(sessionId);
+}
 /**
  * Get the agent preference for a channel.
  */

package/dist/discord-bot.js

@@ -18,6 +18,7 @@ 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';
@@ -89,11 +90,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 (errore.isError(fetched)) {
+                    discordLogger.log(`Failed to fetch partial message ${message.id}:`, fetched.message);
                     return;
                 }
             }
@@ -152,17 +154,11 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         discordLogger.log(`Cannot start session: no project directory for thread ${thread.id}`);
                         return;
                     }
-                    // Include starter message (notification) as context for the session
+                    // Include starter message as context for the session
                     let prompt = message.content;
                     const starterMessage = await thread.fetchStarterMessage().catch(() => null);
-                    if (starterMessage?.content) {
-                        // Strip notification prefix if present
-                        const notificationContent = starterMessage.content
-                            .replace(/^📢 \*\*Notification\*\*\n?/, '')
-                            .trim();
-                        if (notificationContent) {
-                            prompt = `Context from notification:\n${notificationContent}\n\nUser request:\n${message.content}`;
-                        }
+                    if (starterMessage?.content && starterMessage.content !== message.content) {
+                        prompt = `Context from thread:\n${starterMessage.content}\n\nUser request:\n${message.content}`;
                     }
                     await handleOpencodeSession({
                         prompt,
@@ -179,28 +175,39 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 if (projectDirectory) {
                     try {
                         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+                        if (errore.isError(getClient)) {
+                            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) {
@@ -316,35 +323,35 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             }
         }
     });
-    // Magic prefix used by `kimaki send` CLI command to initiate sessions
-    const BOT_SESSION_PREFIX = '🤖 **Bot-initiated session**';
-    // Handle bot-initiated threads created by `kimaki send`
+    // Handle bot-initiated threads created by `kimaki send` (without --notify-only)
     discordClient.on(Events.ThreadCreate, async (thread, newlyCreated) => {
         try {
             if (!newlyCreated) {
                 return;
             }
+            // Check if this thread is marked for auto-start in the database
+            const db = getDatabase();
+            const pendingRow = db
+                .prepare('SELECT thread_id FROM pending_auto_start WHERE thread_id = ?')
+                .get(thread.id);
+            if (!pendingRow) {
+                return; // Not a CLI-initiated auto-start thread
+            }
+            // Remove from pending table
+            db.prepare('DELETE FROM pending_auto_start WHERE thread_id = ?').run(thread.id);
+            discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`);
             // Only handle threads in text channels
             const parent = thread.parent;
             if (!parent || parent.type !== ChannelType.GuildText) {
                 return;
             }
-            // Get the starter message to check for magic prefix
+            // Get the starter message for the prompt
             const starterMessage = await thread.fetchStarterMessage().catch(() => null);
             if (!starterMessage) {
                 discordLogger.log(`[THREAD_CREATE] Could not fetch starter message for thread ${thread.id}`);
                 return;
             }
-            // Only handle messages from this bot with the magic prefix
-            if (starterMessage.author.id !== discordClient.user?.id) {
-                return;
-            }
-            if (!starterMessage.content.startsWith(BOT_SESSION_PREFIX)) {
-                return;
-            }
-            discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`);
-            // Extract the prompt (everything after the prefix)
-            const prompt = starterMessage.content.slice(BOT_SESSION_PREFIX.length).trim();
+            const prompt = starterMessage.content.trim();
             if (!prompt) {
                 discordLogger.log(`[BOT_SESSION] No prompt found in starter message`);
                 return;

package/dist/errors.js

@@ -0,0 +1,110 @@
+// 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 * as errore from 'errore';
+// ═══════════════════════════════════════════════════════════════════════════
+// INFRASTRUCTURE ERRORS - Server, filesystem, external services
+// ═══════════════════════════════════════════════════════════════════════════
+export class DirectoryNotAccessibleError extends errore.TaggedError('DirectoryNotAccessibleError')() {
+    constructor(args) {
+        super({ ...args, message: `Directory does not exist or is not accessible: ${args.directory}` });
+    }
+}
+export class ServerStartError extends errore.TaggedError('ServerStartError')() {
+    constructor(args) {
+        super({ ...args, message: `Server failed to start on port ${args.port}: ${args.reason}` });
+    }
+}
+export class ServerNotFoundError extends errore.TaggedError('ServerNotFoundError')() {
+    constructor(args) {
+        super({ ...args, message: `OpenCode server not found for directory: ${args.directory}` });
+    }
+}
+export class ServerNotReadyError extends errore.TaggedError('ServerNotReadyError')() {
+    constructor(args) {
+        super({
+            ...args,
+            message: `OpenCode server for directory "${args.directory}" is in an error state (no client available)`,
+        });
+    }
+}
+export class ApiKeyMissingError extends errore.TaggedError('ApiKeyMissingError')() {
+    constructor(args) {
+        super({ ...args, message: `${args.service} API key is required` });
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// DOMAIN ERRORS - Sessions, messages, transcription
+// ═══════════════════════════════════════════════════════════════════════════
+export class SessionNotFoundError extends errore.TaggedError('SessionNotFoundError')() {
+    constructor(args) {
+        super({ ...args, message: `Session ${args.sessionId} not found` });
+    }
+}
+export class SessionCreateError extends errore.TaggedError('SessionCreateError')() {
+}
+export class MessagesNotFoundError extends errore.TaggedError('MessagesNotFoundError')() {
+    constructor(args) {
+        super({ ...args, message: `No messages found for session ${args.sessionId}` });
+    }
+}
+export class TranscriptionError extends errore.TaggedError('TranscriptionError')() {
+    constructor(args) {
+        super({ ...args, message: `Transcription failed: ${args.reason}` });
+    }
+}
+export class GrepSearchError extends errore.TaggedError('GrepSearchError')() {
+    constructor(args) {
+        super({ ...args, message: `Grep search failed for pattern: ${args.pattern}` });
+    }
+}
+export class GlobSearchError extends errore.TaggedError('GlobSearchError')() {
+    constructor(args) {
+        super({ ...args, message: `Glob search failed for pattern: ${args.pattern}` });
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// VALIDATION ERRORS - Input validation, format checks
+// ═══════════════════════════════════════════════════════════════════════════
+export class InvalidAudioFormatError extends errore.TaggedError('InvalidAudioFormatError')() {
+    constructor() {
+        super({ message: 'Invalid audio format' });
+    }
+}
+export class EmptyTranscriptionError extends errore.TaggedError('EmptyTranscriptionError')() {
+    constructor() {
+        super({ message: 'Model returned empty transcription' });
+    }
+}
+export class NoResponseContentError extends errore.TaggedError('NoResponseContentError')() {
+    constructor() {
+        super({ message: 'No response content from model' });
+    }
+}
+export class NoToolResponseError extends errore.TaggedError('NoToolResponseError')() {
+    constructor() {
+        super({ message: 'No valid tool responses' });
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// NETWORK ERRORS - Fetch and HTTP
+// ═══════════════════════════════════════════════════════════════════════════
+export class FetchError extends errore.TaggedError('FetchError')() {
+    constructor(args) {
+        const causeMsg = args.cause instanceof Error ? args.cause.message : String(args.cause);
+        super({ ...args, message: `Fetch failed for ${args.url}: ${causeMsg}` });
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// API ERRORS - External service responses
+// ═══════════════════════════════════════════════════════════════════════════
+export class DiscordApiError extends errore.TaggedError('DiscordApiError')() {
+    constructor(args) {
+        super({ ...args, message: `Discord API error: ${args.status}${args.body ? ` - ${args.body}` : ''}` });
+    }
+}
+export class OpenCodeApiError extends errore.TaggedError('OpenCodeApiError')() {
+    constructor(args) {
+        super({ ...args, message: `OpenCode API error (${args.status})${args.body ? `: ${args.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 (errore.isError(mkdirError)) {
+        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

@@ -12,7 +12,7 @@ import { handleAbortCommand } from './commands/abort.js';
 import { handleShareCommand } from './commands/share.js';
 import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js';
 import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu, } from './commands/model.js';
-import { handleAgentCommand, handleAgentSelectMenu } from './commands/agent.js';
+import { handleAgentCommand, handleAgentSelectMenu, handleQuickAgentCommand } from './commands/agent.js';
 import { handleAskQuestionSelectMenu } from './commands/ask-question.js';
 import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js';
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js';
@@ -94,6 +94,11 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                         await handleRedoCommand({ command: interaction, appId });
                         return;
                 }
+                // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)
+                if (interaction.commandName.endsWith('-agent') && interaction.commandName !== 'agent') {
+                    await handleQuickAgentCommand({ command: interaction, appId });
+                    return;
+                }
                 // Handle user-defined commands (ending with -cmd suffix)
                 if (interaction.commandName.endsWith('-cmd')) {
                     await handleUserCommand({ command: interaction, appId });