kimaki 0.4.22 → 0.4.23

package/dist/voice.js

@@ -1,16 +1,213 @@
-import { GoogleGenAI } from '@google/genai';
+import { GoogleGenAI, Type, } from '@google/genai';
 import { createLogger } from './logger.js';
+import { glob } from 'glob';
+import { ripGrep } from 'ripgrep-js';
 const voiceLogger = createLogger('VOICE');
-export async function transcribeAudio({ audio, prompt, language, temperature, geminiApiKey, }) {
+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 {
+        return 'grep search failed';
+    }
+}
+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'}`;
+    }
+}
+const grepToolDeclaration = {
+    name: 'grep',
+    description: 'Search for a pattern in file contents to verify if a technical term, function name, or variable exists in the code. Use this to check if transcribed words match actual code.',
+    parameters: {
+        type: Type.OBJECT,
+        properties: {
+            pattern: {
+                type: Type.STRING,
+                description: 'The search pattern (case-insensitive). Can be a word, function name, or partial match.',
+            },
+        },
+        required: ['pattern'],
+    },
+};
+const globToolDeclaration = {
+    name: 'glob',
+    description: 'Search for files by name pattern. Use this to verify if a filename or directory mentioned in the audio actually exists in the project.',
+    parameters: {
+        type: Type.OBJECT,
+        properties: {
+            pattern: {
+                type: Type.STRING,
+                description: 'The glob pattern to match files. Examples: "*.ts", "**/*.json", "**/config*", "src/**/*.tsx"',
+            },
+        },
+        required: ['pattern'],
+    },
+};
+const transcriptionResultToolDeclaration = {
+    name: 'transcriptionResult',
+    description: 'MANDATORY: You MUST call this tool to complete the task. This is the ONLY way to return results - text responses are ignored. Call this with your transcription, even if imperfect. An imperfect transcription is better than none.',
+    parameters: {
+        type: Type.OBJECT,
+        properties: {
+            transcription: {
+                type: Type.STRING,
+                description: 'The final transcription of the audio. MUST be non-empty. If audio is unclear, transcribe your best interpretation. If silent, use "[inaudible audio]".',
+            },
+        },
+        required: ['transcription'],
+    },
+};
+function createToolRunner({ directory, }) {
+    const hasDirectory = directory && directory.trim().length > 0;
+    return async ({ name, args }) => {
+        if (name === 'transcriptionResult') {
+            return {
+                type: 'result',
+                transcription: args?.transcription || '',
+            };
+        }
+        if (name === 'grep' && hasDirectory) {
+            const pattern = args?.pattern || '';
+            voiceLogger.log(`Grep search: "${pattern}"`);
+            const output = await runGrep({ pattern, directory });
+            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 });
+            voiceLogger.log(`Glob result: ${output.slice(0, 100)}...`);
+            return { type: 'toolResponse', name: 'glob', output };
+        }
+        return { type: 'skip' };
+    };
+}
+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,
+            },
+            tools,
+        },
+    });
+    const conversationHistory = [...initialContents];
+    let stepsRemaining = maxSteps;
+    while (true) {
+        const candidate = response.candidates?.[0];
+        if (!candidate?.content?.parts) {
+            const text = response.text?.trim();
+            if (text) {
+                voiceLogger.log(`No parts but got text response: "${text.slice(0, 100)}..."`);
+                return text;
+            }
+            throw new Error('Transcription failed: No response content from model');
+        }
+        const functionCalls = candidate.content.parts.filter((part) => 'functionCall' in part && !!part.functionCall);
+        if (functionCalls.length === 0) {
+            const text = response.text?.trim();
+            if (text) {
+                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');
+        }
+        conversationHistory.push({
+            role: 'model',
+            parts: candidate.content.parts,
+        });
+        const functionResponseParts = [];
+        for (const part of functionCalls) {
+            const call = part.functionCall;
+            const args = call.args;
+            const result = await toolRunner({ name: call.name || '', args });
+            if (result.type === 'result') {
+                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 transcription;
+            }
+            if (result.type === 'toolResponse') {
+                stepsRemaining--;
+                const stepsWarning = (() => {
+                    if (stepsRemaining <= 0) {
+                        return '\n\n[CRITICAL: Tool limit reached. You MUST call transcriptionResult NOW. No more grep/glob allowed. Call transcriptionResult immediately with your best transcription.]';
+                    }
+                    if (stepsRemaining === 1) {
+                        return '\n\n[URGENT: FINAL STEP. You MUST call transcriptionResult NOW. Do NOT call grep or glob. Call transcriptionResult with your transcription immediately.]';
+                    }
+                    if (stepsRemaining <= 3) {
+                        return `\n\n[WARNING: Only ${stepsRemaining} steps remaining. Finish searching soon and call transcriptionResult. Do not wait until the last step.]`;
+                    }
+                    return '';
+                })();
+                functionResponseParts.push({
+                    functionResponse: {
+                        name: result.name,
+                        response: { output: result.output + stepsWarning },
+                    },
+                });
+            }
+        }
+        if (functionResponseParts.length === 0) {
+            throw new Error('Transcription failed: No valid tool responses');
+        }
+        conversationHistory.push({
+            role: 'user',
+            parts: functionResponseParts,
+        });
+        response = await genAI.models.generateContent({
+            model,
+            contents: conversationHistory,
+            config: {
+                temperature,
+                thinkingConfig: {
+                    thinkingBudget: 512,
+                },
+                tools: stepsRemaining <= 0 ? [{ functionDeclarations: [transcriptionResultToolDeclaration] }] : tools,
+            },
+        });
+    }
+}
+export async function transcribeAudio({ audio, prompt, language, temperature, geminiApiKey, directory, sessionMessages, }) {
     try {
-        // Use provided API key or fall back to environment variable
         const apiKey = geminiApiKey || process.env.GEMINI_API_KEY;
         if (!apiKey) {
             throw new Error('Gemini API key is required for audio transcription');
         }
-        // Initialize Google Generative AI
         const genAI = new GoogleGenAI({ apiKey });
-        // Convert audio to base64 string if it's not already
         let audioBase64;
         if (typeof audio === 'string') {
             audioBase64 = audio;
@@ -27,44 +224,69 @@ export async function transcribeAudio({ audio, prompt, language, temperature, ge
         else {
             throw new Error('Invalid audio format');
         }
-        // Build the transcription prompt
-        let transcriptionPrompt = `Transcribe this audio accurately. The transcription will be sent to a coding agent (like Claude Code) to execute programming tasks.
+        const languageHint = language ? `The audio is in ${language}.\n\n` : '';
+        const transcriptionPrompt = `${languageHint}Transcribe this audio for a coding agent (like Claude Code or OpenCode).
 
-Assume the speaker is using technical and programming terminology: file paths, function names, CLI commands, package names, API names, programming concepts, etc. Prioritize technical accuracy over literal transcription - if a word sounds like a common programming term, prefer that interpretation.
+CRITICAL REQUIREMENT: You MUST call the "transcriptionResult" tool to complete this task.
+- The transcriptionResult tool is the ONLY way to return results
+- Text responses are completely ignored - only tool calls work
+- You MUST call transcriptionResult even if you run out of tool calls
+- An imperfect transcription is better than no transcription
+- DO NOT end without calling transcriptionResult
 
-If the spoken message is unclear or ambiguous, rephrase it to better convey the intended meaning for a coding agent. The goal is effective communication of the user's programming intent, not a word-for-word transcription.
+This is a software development environment. The speaker is giving instructions to an AI coding assistant. Expect:
+- File paths, function names, CLI commands, package names, API endpoints
 
-Here are relevant filenames and context that may appear in the audio:
+RULES:
+1. You have LIMITED tool calls - use grep/glob sparingly, call them in parallel
+2. If audio is unclear, transcribe your best interpretation
+3. If audio seems silent/empty, call transcriptionResult with "[inaudible audio]"
+4. When warned about remaining steps, STOP searching and call transcriptionResult immediately
+
+Common corrections (apply without tool calls):
+- "reacked" → "React", "jason" → "JSON", "get hub" → "GitHub", "no JS" → "Node.js", "dacker" → "Docker"
+
+Project context for reference:
 <context>
 ${prompt}
 </context>
-`;
-        if (language) {
-            transcriptionPrompt += `\nThe audio is in ${language}.`;
-        }
-        // Create the content with audio using the inline data format
-        const response = await genAI.models.generateContent({
-            model: 'gemini-2.5-flash',
-            contents: [
-                {
-                    parts: [
-                        { text: transcriptionPrompt },
-                        {
-                            inlineData: {
-                                data: audioBase64,
-                                mimeType: 'audio/mpeg',
-                            },
+${sessionMessages ? `\nRecent session messages:\n<session_messages>\n${sessionMessages}\n</session_messages>` : ''}
+
+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,
+                    ...(hasDirectory ? [grepToolDeclaration, globToolDeclaration] : []),
+                ],
+            },
+        ];
+        const initialContents = [
+            {
+                role: 'user',
+                parts: [
+                    { text: transcriptionPrompt },
+                    {
+                        inlineData: {
+                            data: audioBase64,
+                            mimeType: 'audio/mpeg',
                         },
-                    ],
-                },
-            ],
-            config: temperature !== undefined
-                ? {
-                    temperature,
-                }
-                : undefined,
+                    },
+                ],
+            },
+        ];
+        const toolRunner = createToolRunner({ directory });
+        return await runTranscriptionLoop({
+            genAI,
+            model: 'gemini-2.5-flash',
+            initialContents,
+            tools,
+            temperature: temperature ?? 0.3,
+            toolRunner,
         });
-        return response.text || '';
     }
     catch (error) {
         voiceLogger.error('Failed to transcribe audio:', error);

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.22",
+  "version": "0.4.23",
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",
     "prepublishOnly": "pnpm tsc",
@@ -43,6 +43,7 @@
     "cac": "^6.7.14",
     "discord.js": "^14.16.3",
     "domhandler": "^5.0.3",
+    "glob": "^13.0.0",
     "go-try": "^3.0.2",
     "htmlparser2": "^10.0.0",
     "js-yaml": "^4.1.0",
@@ -50,6 +51,7 @@
     "picocolors": "^1.1.1",
     "pretty-ms": "^9.3.0",
     "prism-media": "^1.3.5",
+    "ripgrep-js": "^3.0.0",
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
     "zod": "^4.2.1"

package/src/channel-management.ts

@@ -0,0 +1,145 @@
+import {
+  ChannelType,
+  type CategoryChannel,
+  type Guild,
+  type TextChannel,
+} from 'discord.js'
+import path from 'node:path'
+import { getDatabase } from './database.js'
+import { extractTagsArrays } from './xml.js'
+
+export async function ensureKimakiCategory(guild: Guild): Promise<CategoryChannel> {
+  const existingCategory = guild.channels.cache.find(
+    (channel): channel is CategoryChannel => {
+      if (channel.type !== ChannelType.GuildCategory) {
+        return false
+      }
+
+      return channel.name.toLowerCase() === 'kimaki'
+    },
+  )
+
+  if (existingCategory) {
+    return existingCategory
+  }
+
+  return guild.channels.create({
+    name: 'Kimaki',
+    type: ChannelType.GuildCategory,
+  })
+}
+
+export async function ensureKimakiAudioCategory(guild: Guild): Promise<CategoryChannel> {
+  const existingCategory = guild.channels.cache.find(
+    (channel): channel is CategoryChannel => {
+      if (channel.type !== ChannelType.GuildCategory) {
+        return false
+      }
+
+      return channel.name.toLowerCase() === 'kimaki audio'
+    },
+  )
+
+  if (existingCategory) {
+    return existingCategory
+  }
+
+  return guild.channels.create({
+    name: 'Kimaki Audio',
+    type: ChannelType.GuildCategory,
+  })
+}
+
+export async function createProjectChannels({
+  guild,
+  projectDirectory,
+  appId,
+}: {
+  guild: Guild
+  projectDirectory: string
+  appId: string
+}): Promise<{ textChannelId: string; voiceChannelId: string; channelName: string }> {
+  const baseName = path.basename(projectDirectory)
+  const channelName = `${baseName}`
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .slice(0, 100)
+
+  const kimakiCategory = await ensureKimakiCategory(guild)
+  const kimakiAudioCategory = await ensureKimakiAudioCategory(guild)
+
+  const textChannel = await guild.channels.create({
+    name: channelName,
+    type: ChannelType.GuildText,
+    parent: kimakiCategory,
+    topic: `<kimaki><directory>${projectDirectory}</directory><app>${appId}</app></kimaki>`,
+  })
+
+  const voiceChannel = await guild.channels.create({
+    name: channelName,
+    type: ChannelType.GuildVoice,
+    parent: kimakiAudioCategory,
+  })
+
+  getDatabase()
+    .prepare(
+      'INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)',
+    )
+    .run(textChannel.id, projectDirectory, 'text')
+
+  getDatabase()
+    .prepare(
+      'INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)',
+    )
+    .run(voiceChannel.id, projectDirectory, 'voice')
+
+  return {
+    textChannelId: textChannel.id,
+    voiceChannelId: voiceChannel.id,
+    channelName,
+  }
+}
+
+export type ChannelWithTags = {
+  id: string
+  name: string
+  description: string | null
+  kimakiDirectory?: string
+  kimakiApp?: string
+}
+
+export async function getChannelsWithDescriptions(
+  guild: Guild,
+): Promise<ChannelWithTags[]> {
+  const channels: ChannelWithTags[] = []
+
+  guild.channels.cache
+    .filter((channel) => channel.isTextBased())
+    .forEach((channel) => {
+      const textChannel = channel as TextChannel
+      const description = textChannel.topic || null
+
+      let kimakiDirectory: string | undefined
+      let kimakiApp: string | undefined
+
+      if (description) {
+        const extracted = extractTagsArrays({
+          xml: description,
+          tags: ['kimaki.directory', 'kimaki.app'],
+        })
+
+        kimakiDirectory = extracted['kimaki.directory']?.[0]?.trim()
+        kimakiApp = extracted['kimaki.app']?.[0]?.trim()
+      }
+
+      channels.push({
+        id: textChannel.id,
+        name: textChannel.name,
+        description,
+        kimakiDirectory,
+        kimakiApp,
+      })
+    })
+
+  return channels
+}

package/src/cli.ts

@@ -23,7 +23,7 @@ import {
   ensureKimakiCategory,
   createProjectChannels,
   type ChannelWithTags,
-} from './discordBot.js'
+} from './discord-bot.js'
 import type { OpencodeClient } from '@opencode-ai/sdk'
 import {
   Events,
@@ -180,6 +180,14 @@ async function registerCommands(token: string, appId: string) {
       .setName('share')
       .setDescription('Share the current session as a public URL')
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('fork')
+      .setDescription('Fork the session from a past user message')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('model')
+      .setDescription('Set the preferred model for this channel or session')
+      .toJSON(),
   ]
 
   const rest = new REST().setToken(token)

package/src/database.ts

@@ -0,0 +1,155 @@
+import Database from 'better-sqlite3'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { createLogger } from './logger.js'
+
+const dbLogger = createLogger('DB')
+
+let db: Database.Database | null = null
+
+export function getDatabase(): Database.Database {
+  if (!db) {
+    const kimakiDir = path.join(os.homedir(), '.kimaki')
+
+    try {
+      fs.mkdirSync(kimakiDir, { recursive: true })
+    } catch (error) {
+      dbLogger.error('Failed to create ~/.kimaki directory:', error)
+    }
+
+    const dbPath = path.join(kimakiDir, 'discord-sessions.db')
+
+    dbLogger.log(`Opening database at: ${dbPath}`)
+    db = new Database(dbPath)
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS thread_sessions (
+        thread_id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS part_messages (
+        part_id TEXT PRIMARY KEY,
+        message_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS bot_tokens (
+        app_id TEXT PRIMARY KEY,
+        token TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS channel_directories (
+        channel_id TEXT PRIMARY KEY,
+        directory TEXT NOT NULL,
+        channel_type TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS bot_api_keys (
+        app_id TEXT PRIMARY KEY,
+        gemini_api_key TEXT,
+        xai_api_key TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
+    runModelMigrations(db)
+  }
+
+  return db
+}
+
+/**
+ * Run migrations for model preferences tables.
+ * Called on startup and can be called on-demand.
+ */
+export function runModelMigrations(database?: Database.Database): void {
+  const targetDb = database || getDatabase()
+
+  targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_models (
+      channel_id TEXT PRIMARY KEY,
+      model_id TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `)
+
+  targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS session_models (
+      session_id TEXT PRIMARY KEY,
+      model_id TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `)
+
+  dbLogger.log('Model preferences migrations complete')
+}
+
+/**
+ * Get the model preference for a channel.
+ * @returns Model ID in format "provider_id/model_id" or undefined
+ */
+export function getChannelModel(channelId: string): string | undefined {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT model_id FROM channel_models WHERE channel_id = ?')
+    .get(channelId) as { model_id: string } | undefined
+  return row?.model_id
+}
+
+/**
+ * Set the model preference for a channel.
+ * @param modelId Model ID in format "provider_id/model_id"
+ */
+export function setChannelModel(channelId: string, modelId: string): void {
+  const db = getDatabase()
+  db.prepare(
+    `INSERT INTO channel_models (channel_id, model_id, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET model_id = ?, updated_at = CURRENT_TIMESTAMP`
+  ).run(channelId, modelId, modelId)
+}
+
+/**
+ * Get the model preference for a session.
+ * @returns Model ID in format "provider_id/model_id" or undefined
+ */
+export function getSessionModel(sessionId: string): string | undefined {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT model_id FROM session_models WHERE session_id = ?')
+    .get(sessionId) as { model_id: string } | undefined
+  return row?.model_id
+}
+
+/**
+ * Set the model preference for a session.
+ * @param modelId Model ID in format "provider_id/model_id"
+ */
+export function setSessionModel(sessionId: string, modelId: string): void {
+  const db = getDatabase()
+  db.prepare(
+    `INSERT OR REPLACE INTO session_models (session_id, model_id) VALUES (?, ?)`
+  ).run(sessionId, modelId)
+}
+
+export function closeDatabase(): void {
+  if (db) {
+    db.close()
+    db = null
+  }
+}