kimaki 0.4.38 → 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.38",
+  "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/cli.ts

@@ -40,6 +40,7 @@ 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'
@@ -181,6 +182,7 @@ type AgentInfo = {
   name: string
   description?: string
   mode: string
+  hidden?: boolean
 }
 
 async function registerCommands({
@@ -343,8 +345,10 @@ async function registerCommands({
   }
 
   // Add agent-specific quick commands like /plan-agent, /build-agent
-  // Filter to primary/all mode agents (same as /agent command shows)
-  const primaryAgents = agents.filter((a) => a.mode === 'primary' || a.mode === 'all')
+  // 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`
@@ -577,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()

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) {

package/src/commands/agent.ts

@@ -15,6 +15,7 @@ import { getDatabase, setChannelAgent, setSessionAgent, clearSessionModel, runMo
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const agentLogger = createLogger('AGENT')
 
@@ -161,6 +162,10 @@ export async function handleAgentCommand({
 
   try {
     const getClient = await initializeOpencodeForDirectory(context.dir)
+    if (errore.isError(getClient)) {
+      await interaction.editReply({ content: getClient.message })
+      return
+    }
 
     const agentsResponse = await getClient().app.agents({
       query: { directory: context.dir },
@@ -172,7 +177,10 @@ export async function handleAgentCommand({
     }
 
     const agents = agentsResponse.data
-      .filter((a) => a.mode === 'primary' || a.mode === 'all')
+      .filter((agent) => {
+        const hidden = (agent as { hidden?: boolean }).hidden
+        return (agent.mode === 'primary' || agent.mode === 'all') && !hidden
+      })
       .slice(0, 25)
 
     if (agents.length === 0) {
@@ -289,6 +297,10 @@ export async function handleQuickAgentCommand({
 
   try {
     const getClient = await initializeOpencodeForDirectory(context.dir)
+    if (errore.isError(getClient)) {
+      await command.editReply({ content: getClient.message })
+      return
+    }
 
     const agentsResponse = await getClient().app.agents({
       query: { directory: context.dir },

package/src/commands/fork.ts

@@ -14,6 +14,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from '../discord-utils.js'
 import { collectLastAssistantParts } from '../message-formatting.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const sessionLogger = createLogger('SESSION')
 const forkLogger = createLogger('FORK')
@@ -71,9 +72,15 @@ export async function handleForkCommand(interaction: ChatInputCommandInteraction
 
   const sessionId = row.session_id
 
-  try {
-    const getClient = await initializeOpencodeForDirectory(directory)
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (errore.isError(getClient)) {
+    await interaction.editReply({
+      content: `Failed to load messages: ${getClient.message}`,
+    })
+    return
+  }
 
+  try {
     const messagesResponse = await getClient().session.messages({
       path: { id: sessionId },
     })
@@ -85,7 +92,7 @@ export async function handleForkCommand(interaction: ChatInputCommandInteraction
       return
     }
 
-    const userMessages = messagesResponse.data.filter((m) => m.info.role === 'user')
+    const userMessages = messagesResponse.data.filter((m: { info: { role: string } }) => m.info.role === 'user')
 
     if (userMessages.length === 0) {
       await interaction.editReply({
@@ -96,8 +103,8 @@ export async function handleForkCommand(interaction: ChatInputCommandInteraction
 
     const recentMessages = userMessages.slice(-25)
 
-    const options = recentMessages.map((m, index) => {
-      const textPart = m.parts.find((p) => p.type === 'text') as
+    const options = recentMessages.map((m: { parts: Array<{ type: string; text?: string }>; info: { id: string; time: { created: number } } }, index: number) => {
+      const textPart = m.parts.find((p: { type: string }) => p.type === 'text') as
         | { type: 'text'; text: string }
         | undefined
       const preview = textPart?.text?.slice(0, 80) || '(no text)'
@@ -163,9 +170,13 @@ export async function handleForkSelectMenu(
 
   await interaction.deferReply({ ephemeral: false })
 
-  try {
-    const getClient = await initializeOpencodeForDirectory(directory)
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (errore.isError(getClient)) {
+    await interaction.editReply(`Failed to fork session: ${getClient.message}`)
+    return
+  }
 
+  try {
     const forkResponse = await getClient().session.fork({
       path: { id: sessionId },
       body: { messageID: selectedMessageId },

package/src/commands/model.ts

@@ -15,6 +15,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
 import { abortAndRetrySession } from '../session-handler.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const modelLogger = createLogger('MODEL')
 
@@ -128,6 +129,10 @@ export async function handleModelCommand({
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (errore.isError(getClient)) {
+      await interaction.editReply({ content: getClient.message })
+      return
+    }
 
     const providersResponse = await getClient().provider.list({
       query: { directory: projectDirectory },
@@ -232,6 +237,13 @@ export async function handleProviderSelectMenu(
 
   try {
     const getClient = await initializeOpencodeForDirectory(context.dir)
+    if (errore.isError(getClient)) {
+      await interaction.editReply({
+        content: getClient.message,
+        components: [],
+      })
+      return
+    }
 
     const providersResponse = await getClient().provider.list({
       query: { directory: context.dir },