kimaki 0.4.37 → 0.4.39

package/dist/voice.js

@@ -1,49 +1,51 @@
 // Audio transcription service using Google Gemini.
 // Transcribes voice messages with code-aware context, using grep/glob tools
 // to verify technical terms, filenames, and function names in the codebase.
+// Uses errore for type-safe error handling.
 import { GoogleGenAI, Type } from '@google/genai';
+import * as errore from 'errore';
 import { createLogger } from './logger.js';
 import { glob } from 'glob';
 import { ripGrep } from 'ripgrep-js';
+import { ApiKeyMissingError, InvalidAudioFormatError, TranscriptionError, EmptyTranscriptionError, NoResponseContentError, NoToolResponseError, GrepSearchError, GlobSearchError, } from './errors.js';
 const voiceLogger = createLogger('VOICE');
-async function runGrep({ pattern, directory, }) {
-    try {
-        const results = await ripGrep(directory, {
-            string: pattern,
-            globs: ['!node_modules/**', '!.git/**', '!dist/**', '!build/**'],
-        });
-        if (results.length === 0) {
-            return 'No matches found';
-        }
-        const output = results
-            .slice(0, 10)
-            .map((match) => {
-            return `${match.path.text}:${match.line_number}: ${match.lines.text.trim()}`;
-        })
-            .join('\n');
-        return output.slice(0, 2000);
-    }
-    catch (e) {
-        voiceLogger.error('grep search failed:', e);
-        return 'grep search failed';
-    }
+function runGrep({ pattern, directory }) {
+    return errore.tryAsync({
+        try: async () => {
+            const results = await ripGrep(directory, {
+                string: pattern,
+                globs: ['!node_modules/**', '!.git/**', '!dist/**', '!build/**'],
+            });
+            if (results.length === 0) {
+                return 'No matches found';
+            }
+            const output = results
+                .slice(0, 10)
+                .map((match) => {
+                return `${match.path.text}:${match.line_number}: ${match.lines.text.trim()}`;
+            })
+                .join('\n');
+            return output.slice(0, 2000);
+        },
+        catch: (e) => new GrepSearchError({ pattern, cause: e }),
+    });
 }
-async function runGlob({ pattern, directory, }) {
-    try {
-        const files = await glob(pattern, {
-            cwd: directory,
-            nodir: false,
-            ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**'],
-            maxDepth: 10,
-        });
-        if (files.length === 0) {
-            return 'No files found';
-        }
-        return files.slice(0, 30).join('\n');
-    }
-    catch (error) {
-        return `Glob search failed: ${error instanceof Error ? error.message : 'Unknown error'}`;
-    }
+function runGlob({ pattern, directory }) {
+    return errore.tryAsync({
+        try: async () => {
+            const files = await glob(pattern, {
+                cwd: directory,
+                nodir: false,
+                ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**'],
+                maxDepth: 10,
+            });
+            if (files.length === 0) {
+                return 'No files found';
+            }
+            return files.slice(0, 30).join('\n');
+        },
+        catch: (e) => new GlobSearchError({ pattern, cause: e }),
+    });
 }
 const grepToolDeclaration = {
     name: 'grep',
@@ -99,14 +101,28 @@ function createToolRunner({ directory }) {
         if (name === 'grep' && hasDirectory) {
             const pattern = args?.pattern || '';
             voiceLogger.log(`Grep search: "${pattern}"`);
-            const output = await runGrep({ pattern, directory });
+            const result = await runGrep({ pattern, directory });
+            const output = (() => {
+                if (errore.isError(result)) {
+                    voiceLogger.error('grep search failed:', result);
+                    return 'grep search failed';
+                }
+                return result;
+            })();
             voiceLogger.log(`Grep result: ${output.slice(0, 100)}...`);
             return { type: 'toolResponse', name: 'grep', output };
         }
         if (name === 'glob' && hasDirectory) {
             const pattern = args?.pattern || '';
             voiceLogger.log(`Glob search: "${pattern}"`);
-            const output = await runGlob({ pattern, directory });
+            const result = await runGlob({ pattern, directory });
+            const output = (() => {
+                if (errore.isError(result)) {
+                    voiceLogger.error('glob search failed:', result);
+                    return 'glob search failed';
+                }
+                return result;
+            })();
             voiceLogger.log(`Glob result: ${output.slice(0, 100)}...`);
             return { type: 'toolResponse', name: 'glob', output };
         }
@@ -114,17 +130,25 @@ function createToolRunner({ directory }) {
     };
 }
 export async function runTranscriptionLoop({ genAI, model, initialContents, tools, temperature, toolRunner, maxSteps = 10, }) {
-    let response = await genAI.models.generateContent({
-        model,
-        contents: initialContents,
-        config: {
-            temperature,
-            thinkingConfig: {
-                thinkingBudget: 1024,
+    // Wrap external API call that can throw
+    const initialResponse = await errore.tryAsync({
+        try: () => genAI.models.generateContent({
+            model,
+            contents: initialContents,
+            config: {
+                temperature,
+                thinkingConfig: {
+                    thinkingBudget: 1024,
+                },
+                tools,
             },
-            tools,
-        },
+        }),
+        catch: (e) => new TranscriptionError({ reason: `API call failed: ${String(e)}`, cause: e }),
     });
+    if (errore.isError(initialResponse)) {
+        return initialResponse;
+    }
+    let response = initialResponse;
     const conversationHistory = [...initialContents];
     let stepsRemaining = maxSteps;
     while (true) {
@@ -135,7 +159,7 @@ export async function runTranscriptionLoop({ genAI, model, initialContents, tool
                 voiceLogger.log(`No parts but got text response: "${text.slice(0, 100)}..."`);
                 return text;
             }
-            throw new Error('Transcription failed: No response content from model');
+            return new NoResponseContentError();
         }
         const functionCalls = candidate.content.parts.filter((part) => 'functionCall' in part && !!part.functionCall);
         if (functionCalls.length === 0) {
@@ -144,7 +168,7 @@ export async function runTranscriptionLoop({ genAI, model, initialContents, tool
                 voiceLogger.log(`No function calls but got text: "${text.slice(0, 100)}..."`);
                 return text;
             }
-            throw new Error('Transcription failed: Model did not produce a transcription');
+            return new TranscriptionError({ reason: 'Model did not produce a transcription' });
         }
         conversationHistory.push({
             role: 'model',
@@ -159,7 +183,7 @@ export async function runTranscriptionLoop({ genAI, model, initialContents, tool
                 const transcription = result.transcription?.trim() || '';
                 voiceLogger.log(`Transcription result received: "${transcription.slice(0, 100)}..."`);
                 if (!transcription) {
-                    throw new Error('Transcription failed: Model returned empty transcription');
+                    return new EmptyTranscriptionError();
                 }
                 return transcription;
             }
@@ -186,67 +210,76 @@ export async function runTranscriptionLoop({ genAI, model, initialContents, tool
             }
         }
         if (functionResponseParts.length === 0) {
-            throw new Error('Transcription failed: No valid tool responses');
+            return new NoToolResponseError();
         }
         conversationHistory.push({
             role: 'user',
             parts: functionResponseParts,
         });
-        response = await genAI.models.generateContent({
-            model,
-            contents: conversationHistory,
-            config: {
-                temperature,
-                thinkingConfig: {
-                    thinkingBudget: 512,
+        // Wrap external API call that can throw
+        const nextResponse = await errore.tryAsync({
+            try: () => genAI.models.generateContent({
+                model,
+                contents: conversationHistory,
+                config: {
+                    temperature,
+                    thinkingConfig: {
+                        thinkingBudget: 512,
+                    },
+                    tools: stepsRemaining <= 0
+                        ? [{ functionDeclarations: [transcriptionResultToolDeclaration] }]
+                        : tools,
                 },
-                tools: stepsRemaining <= 0
-                    ? [{ functionDeclarations: [transcriptionResultToolDeclaration] }]
-                    : tools,
-            },
+            }),
+            catch: (e) => new TranscriptionError({ reason: `API call failed: ${String(e)}`, cause: e }),
         });
+        if (errore.isError(nextResponse)) {
+            return nextResponse;
+        }
+        response = nextResponse;
     }
 }
-export async function transcribeAudio({ audio, prompt, language, temperature, geminiApiKey, directory, currentSessionContext, lastSessionContext, }) {
-    try {
-        const apiKey = geminiApiKey || process.env.GEMINI_API_KEY;
-        if (!apiKey) {
-            throw new Error('Gemini API key is required for audio transcription');
-        }
-        const genAI = new GoogleGenAI({ apiKey });
-        let audioBase64;
+export function transcribeAudio({ audio, prompt, language, temperature, geminiApiKey, directory, currentSessionContext, lastSessionContext, }) {
+    const apiKey = geminiApiKey || process.env.GEMINI_API_KEY;
+    if (!apiKey) {
+        return Promise.resolve(new ApiKeyMissingError({ service: 'Gemini' }));
+    }
+    const genAI = new GoogleGenAI({ apiKey });
+    const audioBase64 = (() => {
         if (typeof audio === 'string') {
-            audioBase64 = audio;
-        }
-        else if (audio instanceof Buffer) {
-            audioBase64 = audio.toString('base64');
+            return audio;
         }
-        else if (audio instanceof Uint8Array) {
-            audioBase64 = Buffer.from(audio).toString('base64');
+        if (audio instanceof Buffer) {
+            return audio.toString('base64');
         }
-        else if (audio instanceof ArrayBuffer) {
-            audioBase64 = Buffer.from(audio).toString('base64');
+        if (audio instanceof Uint8Array) {
+            return Buffer.from(audio).toString('base64');
         }
-        else {
-            throw new Error('Invalid audio format');
+        if (audio instanceof ArrayBuffer) {
+            return Buffer.from(audio).toString('base64');
         }
-        const languageHint = language ? `The audio is in ${language}.\n\n` : '';
-        // build session context section
-        const sessionContextParts = [];
-        if (lastSessionContext) {
-            sessionContextParts.push(`<last_session>
+        return '';
+    })();
+    if (!audioBase64) {
+        return Promise.resolve(new InvalidAudioFormatError());
+    }
+    const languageHint = language ? `The audio is in ${language}.\n\n` : '';
+    // build session context section
+    const sessionContextParts = [];
+    if (lastSessionContext) {
+        sessionContextParts.push(`<last_session>
 ${lastSessionContext}
 </last_session>`);
-        }
-        if (currentSessionContext) {
-            sessionContextParts.push(`<current_session>
+    }
+    if (currentSessionContext) {
+        sessionContextParts.push(`<current_session>
 ${currentSessionContext}
 </current_session>`);
-        }
-        const sessionContextSection = sessionContextParts.length > 0
-            ? `\nSession context (use to understand references to files, functions, tools used):\n${sessionContextParts.join('\n\n')}`
-            : '';
-        const transcriptionPrompt = `${languageHint}Transcribe this audio for a coding agent (like Claude Code or OpenCode).
+    }
+    const sessionContextSection = sessionContextParts.length > 0
+        ? `\nSession context (use to understand references to files, functions, tools used):\n${sessionContextParts.join('\n\n')}`
+        : '';
+    const transcriptionPrompt = `${languageHint}Transcribe this audio for a coding agent (like Claude Code or OpenCode).
 
 CRITICAL REQUIREMENT: You MUST call the "transcriptionResult" tool to complete this task.
 - The transcriptionResult tool is the ONLY way to return results
@@ -275,42 +308,37 @@ ${sessionContextSection}
 REMEMBER: Call "transcriptionResult" tool with your transcription. This is mandatory.
 
 Note: "critique" is a CLI tool for showing diffs in the browser.`;
-        // const hasDirectory = directory && directory.trim().length > 0
-        const tools = [
-            {
-                functionDeclarations: [
-                    transcriptionResultToolDeclaration,
-                    // grep/glob disabled - was causing transcription to hang
-                    // ...(hasDirectory ? [grepToolDeclaration, globToolDeclaration] : []),
-                ],
-            },
-        ];
-        const initialContents = [
-            {
-                role: 'user',
-                parts: [
-                    { text: transcriptionPrompt },
-                    {
-                        inlineData: {
-                            data: audioBase64,
-                            mimeType: 'audio/mpeg',
-                        },
+    // const hasDirectory = directory && directory.trim().length > 0
+    const tools = [
+        {
+            functionDeclarations: [
+                transcriptionResultToolDeclaration,
+                // grep/glob disabled - was causing transcription to hang
+                // ...(hasDirectory ? [grepToolDeclaration, globToolDeclaration] : []),
+            ],
+        },
+    ];
+    const initialContents = [
+        {
+            role: 'user',
+            parts: [
+                { text: transcriptionPrompt },
+                {
+                    inlineData: {
+                        data: audioBase64,
+                        mimeType: 'audio/mpeg',
                     },
-                ],
-            },
-        ];
-        const toolRunner = createToolRunner({ directory });
-        return await runTranscriptionLoop({
-            genAI,
-            model: 'gemini-2.5-flash',
-            initialContents,
-            tools,
-            temperature: temperature ?? 0.3,
-            toolRunner,
-        });
-    }
-    catch (error) {
-        voiceLogger.error('Failed to transcribe audio:', error);
-        throw new Error(`Audio transcription failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
+                },
+            ],
+        },
+    ];
+    const toolRunner = createToolRunner({ directory });
+    return runTranscriptionLoop({
+        genAI,
+        model: 'gemini-2.5-flash',
+        initialContents,
+        tools,
+        temperature: temperature ?? 0.3,
+        toolRunner,
+    });
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.37",
+  "version": "0.4.39",
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",
     "prepublishOnly": "pnpm tsc",
@@ -41,6 +41,7 @@
     "cac": "^6.7.14",
     "discord.js": "^14.16.3",
     "domhandler": "^5.0.3",
+    "errore": "^0.5.2",
     "glob": "^13.0.0",
     "htmlparser2": "^10.0.0",
     "js-yaml": "^4.1.0",

package/src/channel-management.ts

@@ -11,7 +11,9 @@ export async function ensureKimakiCategory(
   guild: Guild,
   botName?: string,
 ): Promise<CategoryChannel> {
-  const categoryName = botName ? `Kimaki ${botName}` : 'Kimaki'
+  // Skip appending bot name if it's already "kimaki" to avoid "Kimaki kimaki"
+  const isKimakiBot = botName?.toLowerCase() === 'kimaki'
+  const categoryName = botName && !isKimakiBot ? `Kimaki ${botName}` : 'Kimaki'
 
   const existingCategory = guild.channels.cache.find((channel): channel is CategoryChannel => {
     if (channel.type !== ChannelType.GuildCategory) {
@@ -35,7 +37,9 @@ export async function ensureKimakiAudioCategory(
   guild: Guild,
   botName?: string,
 ): Promise<CategoryChannel> {
-  const categoryName = botName ? `Kimaki Audio ${botName}` : 'Kimaki Audio'
+  // Skip appending bot name if it's already "kimaki" to avoid "Kimaki Audio kimaki"
+  const isKimakiBot = botName?.toLowerCase() === 'kimaki'
+  const categoryName = botName && !isKimakiBot ? `Kimaki Audio ${botName}` : 'Kimaki Audio'
 
   const existingCategory = guild.channels.cache.find((channel): channel is CategoryChannel => {
     if (channel.type !== ChannelType.GuildCategory) {

package/src/cli.ts

@@ -40,12 +40,14 @@ import {
 } from 'discord.js'
 import path from 'node:path'
 import fs from 'node:fs'
+import * as errore from 'errore'
 
 import { createLogger } from './logger.js'
 import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
 import http from 'node:http'
 import { setDataDir, getDataDir, getLockPort } from './config.js'
 import { extractTagsArrays } from './xml.js'
+import { sanitizeAgentName } from './commands/agent.js'
 
 const cliLogger = createLogger('CLI')
 const cli = cac('kimaki')
@@ -176,11 +178,24 @@ type CliOptions = {
 // Commands to skip when registering user commands (reserved names)
 const SKIP_USER_COMMANDS = ['init']
 
-async function registerCommands(
-  token: string,
-  appId: string,
-  userCommands: OpencodeCommand[] = [],
-) {
+type AgentInfo = {
+  name: string
+  description?: string
+  mode: string
+  hidden?: boolean
+}
+
+async function registerCommands({
+  token,
+  appId,
+  userCommands = [],
+  agents = [],
+}: {
+  token: string
+  appId: string
+  userCommands?: OpencodeCommand[]
+  agents?: AgentInfo[]
+}) {
   const commands = [
     new SlashCommandBuilder()
       .setName('resume')
@@ -329,6 +344,24 @@ async function registerCommands(
     )
   }
 
+  // Add agent-specific quick commands like /plan-agent, /build-agent
+  // Filter to primary/all mode agents (same as /agent command shows), excluding hidden agents
+  const primaryAgents = agents.filter(
+    (a) => (a.mode === 'primary' || a.mode === 'all') && !a.hidden,
+  )
+  for (const agent of primaryAgents) {
+    const sanitizedName = sanitizeAgentName(agent.name)
+    const commandName = `${sanitizedName}-agent`
+    const description = agent.description || `Switch to ${agent.name} agent`
+
+    commands.push(
+      new SlashCommandBuilder()
+        .setName(commandName.slice(0, 32)) // Discord limits to 32 chars
+        .setDescription(description.slice(0, 100))
+        .toJSON(),
+    )
+  }
+
   const rest = new REST().setToken(token)
 
   try {
@@ -548,7 +581,12 @@ async function run({ restart, addChannels }: CliOptions) {
   // This is the biggest startup bottleneck (can take 1-30 seconds to spawn and wait for ready)
   const currentDir = process.cwd()
   s.start('Starting OpenCode server...')
-  const opencodePromise = initializeOpencodeForDirectory(currentDir)
+  const opencodePromise = initializeOpencodeForDirectory(currentDir).then((result) => {
+    if (errore.isError(result)) {
+      throw new Error(result.message)
+    }
+    return result
+  })
 
   s.message('Connecting to Discord...')
   const discordClient = await createDiscordClient()
@@ -669,8 +707,8 @@ async function run({ restart, addChannels }: CliOptions) {
 
   s.start('Fetching OpenCode data...')
 
-  // Fetch projects and commands in parallel
-  const [projects, allUserCommands] = await Promise.all([
+  // Fetch projects, commands, and agents in parallel
+  const [projects, allUserCommands, allAgents] = await Promise.all([
     getClient()
       .project.list({})
       .then((r) => r.data || [])
@@ -684,6 +722,10 @@ async function run({ restart, addChannels }: CliOptions) {
       .command.list({ query: { directory: currentDir } })
       .then((r) => r.data || [])
       .catch(() => []),
+    getClient()
+      .app.agents({ query: { directory: currentDir } })
+      .then((r) => r.data || [])
+      .catch(() => []),
   ])
 
   s.stop(`Found ${projects.length} OpenCode project(s)`)
@@ -805,7 +847,7 @@ async function run({ restart, addChannels }: CliOptions) {
   }
 
   cliLogger.log('Registering slash commands asynchronously...')
-  void registerCommands(token, appId, allUserCommands)
+  void registerCommands({ token, appId, userCommands: allUserCommands, agents: allAgents })
     .then(() => {
       cliLogger.log('Slash commands registered!')
     })
@@ -999,12 +1041,7 @@ cli
     }
   })
 
-// Magic prefix used to identify bot-initiated sessions.
-// The running bot will recognize this prefix and start a session.
-const BOT_SESSION_PREFIX = '🤖 **Bot-initiated session**'
-// Notify-only prefix - bot won't start a session, just creates thread for notifications.
-// Reply to the thread to start a session with the notification as context.
-const BOT_NOTIFY_PREFIX = '📢 **Notification**'
+
 
 cli
   .command(
@@ -1263,9 +1300,7 @@ cli
 
       s.message('Creating starter message...')
 
-      // Create starter message with magic prefix
-      // BOT_SESSION_PREFIX triggers AI session, BOT_NOTIFY_PREFIX is notification-only
-      const messagePrefix = notifyOnly ? BOT_NOTIFY_PREFIX : BOT_SESSION_PREFIX
+      // Create starter message with just the prompt (no prefix)
       const starterMessageResponse = await fetch(
         `https://discord.com/api/v10/channels/${channelId}/messages`,
         {
@@ -1275,7 +1310,7 @@ cli
             'Content-Type': 'application/json',
           },
           body: JSON.stringify({
-            content: `${messagePrefix}\n${prompt}`,
+            content: prompt,
           }),
         },
       )
@@ -1315,6 +1350,19 @@ cli
 
       const threadData = (await threadResponse.json()) as { id: string; name: string }
 
+      // Mark thread for auto-start if not notify-only
+      // This is optional - only works if local database exists (for local bot auto-start)
+      if (!notifyOnly) {
+        try {
+          const db = getDatabase()
+          db.prepare('INSERT OR REPLACE INTO pending_auto_start (thread_id) VALUES (?)').run(
+            threadData.id,
+          )
+        } catch {
+          // Database not available (e.g., CI environment) - skip auto-start marking
+        }
+      }
+
       s.stop('Thread created!')
 
       const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`

package/src/commands/abort.ts

@@ -7,6 +7,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { abortControllers } from '../session-handler.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const logger = createLogger('ABORT')
 
@@ -64,14 +65,23 @@ export async function handleAbortCommand({ command }: CommandContext): Promise<v
 
   const sessionId = row.session_id
 
-  try {
-    const existingController = abortControllers.get(sessionId)
-    if (existingController) {
-      existingController.abort(new Error('User requested abort'))
-      abortControllers.delete(sessionId)
-    }
+  const existingController = abortControllers.get(sessionId)
+  if (existingController) {
+    existingController.abort(new Error('User requested abort'))
+    abortControllers.delete(sessionId)
+  }
+
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (errore.isError(getClient)) {
+    await command.reply({
+      content: `Failed to abort: ${getClient.message}`,
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
 
-    const getClient = await initializeOpencodeForDirectory(directory)
+  try {
     await getClient().session.abort({
       path: { id: sessionId },
     })

package/src/commands/add-project.ts

@@ -8,6 +8,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js'
 import { createProjectChannels } from '../channel-management.js'
 import { createLogger } from '../logger.js'
 import { abbreviatePath } from '../utils.js'
+import * as errore from 'errore'
 
 const logger = createLogger('ADD-PROJECT')
 
@@ -25,6 +26,10 @@ export async function handleAddProjectCommand({ command, appId }: CommandContext
   try {
     const currentDir = process.cwd()
     const getClient = await initializeOpencodeForDirectory(currentDir)
+    if (errore.isError(getClient)) {
+      await command.editReply(getClient.message)
+      return
+    }
 
     const projectsResponse = await getClient().project.list({})
     if (!projectsResponse.data) {
@@ -89,6 +94,10 @@ export async function handleAddProjectAutocomplete({
   try {
     const currentDir = process.cwd()
     const getClient = await initializeOpencodeForDirectory(currentDir)
+    if (errore.isError(getClient)) {
+      await interaction.respond([])
+      return
+    }
 
     const projectsResponse = await getClient().project.list({})
     if (!projectsResponse.data) {