kimaki 0.4.7 → 0.4.10

package/README.md

@@ -1,7 +1,69 @@
-creating a new bot
+# Kimaki Discord Bot
 
-- first tell user to go to https://discord.com/developers/applications and create a new app
-- get bot app id
-- get bot token in Discord clicking reset bot token. show a password input
+A Discord bot that integrates OpenCode coding sessions with Discord channels and voice.
 
--
+## Installation
+
+```bash
+npm install -g kimaki
+```
+
+## Setup
+
+Run the interactive setup:
+
+```bash
+kimaki
+```
+
+This will guide you through:
+1. Creating a Discord application at https://discord.com/developers/applications
+2. Getting your bot token
+3. Installing the bot to your Discord server
+4. Creating channels for your OpenCode projects
+
+## Commands
+
+### Start the bot
+
+```bash
+kimaki
+```
+
+### Send a session to Discord
+
+Send an OpenCode session to Discord from the CLI:
+
+```bash
+kimaki send-to-discord <session-id>
+```
+
+Options:
+- `-d, --directory <dir>` - Project directory (defaults to current working directory)
+
+### OpenCode Integration
+
+To use the `/send-to-kimaki-discord` command in OpenCode:
+
+```bash
+npx kimaki install-plugin
+```
+
+Then use `/send-to-kimaki-discord` in OpenCode to send the current session to Discord.
+
+## Discord Slash Commands
+
+Once the bot is running, you can use these commands in Discord:
+
+- `/session <prompt>` - Start a new OpenCode session
+- `/resume <session>` - Resume an existing session
+- `/add-project <project>` - Add a new project to Discord
+- `/accept` - Accept a permission request
+- `/accept-always` - Accept and auto-approve similar requests
+- `/reject` - Reject a permission request
+
+## Voice Support
+
+Join a voice channel that has an associated project directory, and the bot will join with Jarvis-like voice interaction powered by Gemini.
+
+Requires a Gemini API key (prompted during setup).

package/dist/cli.js

@@ -6,6 +6,8 @@ import { getChannelsWithDescriptions, createDiscordClient, getDatabase, startDis
 import { Events, ChannelType, REST, Routes, SlashCommandBuilder, } from 'discord.js';
 import path from 'node:path';
 import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import os from 'node:os';
 import { createLogger } from './logger.js';
 import { spawn, spawnSync, execSync } from 'node:child_process';
 const cliLogger = createLogger('CLI');
@@ -435,5 +437,149 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('send-to-discord <sessionId>', 'Send an OpenCode session to Discord and create a thread for it')
+    .option('-d, --directory <dir>', 'Project directory (defaults to current working directory)')
+    .action(async (sessionId, options) => {
+    try {
+        const directory = options.directory || process.cwd();
+        const db = getDatabase();
+        const botRow = db
+            .prepare('SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+            .get();
+        if (!botRow) {
+            cliLogger.error('No bot credentials found. Run `kimaki` first to set up the bot.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const channelRow = db
+            .prepare('SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?')
+            .get(directory, 'text');
+        if (!channelRow) {
+            cliLogger.error(`No Discord channel found for directory: ${directory}\n` +
+                'Run `kimaki --add-channels` to create a channel for this project.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const s = spinner();
+        s.start('Connecting to Discord...');
+        const discordClient = await createDiscordClient();
+        await new Promise((resolve, reject) => {
+            discordClient.once(Events.ClientReady, () => {
+                resolve();
+            });
+            discordClient.once(Events.Error, reject);
+            discordClient.login(botRow.token).catch(reject);
+        });
+        s.stop('Connected to Discord!');
+        const channel = await discordClient.channels.fetch(channelRow.channel_id);
+        if (!channel || channel.type !== ChannelType.GuildText) {
+            cliLogger.error('Could not find the text channel or it is not a text channel');
+            discordClient.destroy();
+            process.exit(EXIT_NO_RESTART);
+        }
+        const textChannel = channel;
+        s.start('Fetching session from OpenCode...');
+        const getClient = await initializeOpencodeForDirectory(directory);
+        const sessionResponse = await getClient().session.get({
+            path: { id: sessionId },
+        });
+        if (!sessionResponse.data) {
+            s.stop('Session not found');
+            discordClient.destroy();
+            process.exit(EXIT_NO_RESTART);
+        }
+        const session = sessionResponse.data;
+        s.stop(`Found session: ${session.title}`);
+        s.start('Creating Discord thread...');
+        const thread = await textChannel.threads.create({
+            name: `Resume: ${session.title}`.slice(0, 100),
+            autoArchiveDuration: 1440,
+            reason: `Resuming session ${sessionId} from CLI`,
+        });
+        db.prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)').run(thread.id, sessionId);
+        s.stop('Created Discord thread!');
+        s.start('Loading session messages...');
+        const messagesResponse = await getClient().session.messages({
+            path: { id: sessionId },
+        });
+        if (!messagesResponse.data) {
+            s.stop('Failed to fetch session messages');
+            discordClient.destroy();
+            process.exit(EXIT_NO_RESTART);
+        }
+        const messages = messagesResponse.data;
+        await thread.send(`📂 **Resumed session:** ${session.title}\n📅 **Created:** ${new Date(session.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`);
+        let messageCount = 0;
+        for (const message of messages) {
+            if (message.info.role === 'user') {
+                const userParts = message.parts.filter((p) => p.type === 'text' && !p.synthetic);
+                const userTexts = userParts
+                    .map((p) => {
+                    if (p.type === 'text') {
+                        return p.text;
+                    }
+                    return '';
+                })
+                    .filter((t) => t.trim());
+                const userText = userTexts.join('\n\n');
+                if (userText) {
+                    const truncated = userText.length > 1900 ? userText.slice(0, 1900) + '…' : userText;
+                    await thread.send(`**User:**\n${truncated}`);
+                }
+            }
+            else if (message.info.role === 'assistant') {
+                const textParts = message.parts.filter((p) => p.type === 'text');
+                const texts = textParts
+                    .map((p) => {
+                    if (p.type === 'text') {
+                        return p.text;
+                    }
+                    return '';
+                })
+                    .filter((t) => t?.trim());
+                if (texts.length > 0) {
+                    const combinedText = texts.join('\n\n');
+                    const truncated = combinedText.length > 1900 ? combinedText.slice(0, 1900) + '…' : combinedText;
+                    await thread.send(truncated);
+                }
+            }
+            messageCount++;
+        }
+        await thread.send(`✅ **Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`);
+        s.stop(`Loaded ${messageCount} messages`);
+        const guildId = textChannel.guildId;
+        const threadUrl = `https://discord.com/channels/${guildId}/${thread.id}`;
+        note(`Session "${session.title}" has been sent to Discord!\n\nThread: ${threadUrl}`, '✅ Success');
+        discordClient.destroy();
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('install-plugin', 'Install the OpenCode plugin for /send-to-kimaki-discord command')
+    .action(async () => {
+    try {
+        const require = createRequire(import.meta.url);
+        const pluginSrc = require.resolve('./opencode-plugin.ts');
+        const commandSrc = require.resolve('./opencode-command.md');
+        const opencodeConfig = path.join(os.homedir(), '.config', 'opencode');
+        const pluginDir = path.join(opencodeConfig, 'plugin');
+        const commandDir = path.join(opencodeConfig, 'command');
+        fs.mkdirSync(pluginDir, { recursive: true });
+        fs.mkdirSync(commandDir, { recursive: true });
+        const pluginDest = path.join(pluginDir, 'send-to-kimaki-discord.ts');
+        const commandDest = path.join(commandDir, 'send-to-kimaki-discord.md');
+        fs.copyFileSync(pluginSrc, pluginDest);
+        fs.copyFileSync(commandSrc, commandDest);
+        note(`Plugin: ${pluginDest}\nCommand: ${commandDest}\n\nUse /send-to-kimaki-discord in OpenCode to send the current session to Discord.`, '✅ Installed');
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli.help();
 cli.parse();

package/dist/opencode-plugin.js

@@ -0,0 +1,56 @@
+/**
+ * Kimaki Discord Plugin for OpenCode
+ *
+ * Adds /send-to-kimaki-discord command that sends the current session to Discord.
+ *
+ * Installation:
+ *   kimaki install-plugin
+ *
+ * Use in OpenCode TUI:
+ *   /send-to-kimaki-discord
+ */
+export const KimakiDiscordPlugin = async ({ client, $, directory, }) => {
+    return {
+        event: async ({ event }) => {
+            if (event.type !== 'command.executed') {
+                return;
+            }
+            const { name, sessionID } = event.properties;
+            if (name !== 'send-to-kimaki-discord') {
+                return;
+            }
+            if (!sessionID) {
+                await client.tui.showToast({
+                    body: { message: 'No session ID available', variant: 'error' },
+                });
+                return;
+            }
+            await client.tui.showToast({
+                body: { message: 'Creating Discord thread...', variant: 'info' },
+            });
+            try {
+                const result = await $ `npx -y kimaki send-to-discord ${sessionID} -d ${directory}`.text();
+                const urlMatch = result.match(/https:\/\/discord\.com\/channels\/\S+/);
+                const url = urlMatch ? urlMatch[0] : null;
+                await client.tui.showToast({
+                    body: {
+                        message: url ? `Sent to Discord: ${url}` : 'Session sent to Discord',
+                        variant: 'success',
+                    },
+                });
+            }
+            catch (error) {
+                const message = error.stderr?.toString().trim() ||
+                    error.stdout?.toString().trim() ||
+                    error.message ||
+                    String(error);
+                await client.tui.showToast({
+                    body: {
+                        message: `Failed: ${message.slice(0, 100)}`,
+                        variant: 'error',
+                    },
+                });
+            }
+        },
+    };
+};

package/dist/voice.js

@@ -28,7 +28,17 @@ export async function transcribeAudio({ audio, prompt, language, temperature, ge
             throw new Error('Invalid audio format');
         }
         // Build the transcription prompt
-        let transcriptionPrompt = `Please transcribe this audio file accurately. Here is some relevant information and filenames that may be present in the audio:\n<context>\n${prompt}\n</context>\n`;
+        let transcriptionPrompt = `Transcribe this audio accurately. The transcription will be sent to a coding agent (like Claude Code) to execute programming tasks.
+
+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.
+
+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.
+
+Here are relevant filenames and context that may appear in the audio:
+<context>
+${prompt}
+</context>
+`;
         if (language) {
             transcriptionPrompt += `\nThe audio is in ${language}.`;
         }

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.7",
+  "version": "0.4.10",
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",
     "prepublishOnly": "pnpm tsc",
@@ -21,6 +21,7 @@
     "bin.js"
   ],
   "devDependencies": {
+    "@opencode-ai/plugin": "^1.0.119",
     "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "latest",
     "@types/js-yaml": "^4.0.9",

package/src/cli.ts

@@ -36,6 +36,8 @@ import {
 } from 'discord.js'
 import path from 'node:path'
 import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import os from 'node:os'
 import { createLogger } from './logger.js'
 import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
 
@@ -655,5 +657,215 @@ cli
     }
   })
 
+cli
+  .command(
+    'send-to-discord <sessionId>',
+    'Send an OpenCode session to Discord and create a thread for it',
+  )
+  .option('-d, --directory <dir>', 'Project directory (defaults to current working directory)')
+  .action(async (sessionId: string, options: { directory?: string }) => {
+    try {
+      const directory = options.directory || process.cwd()
+      
+      const db = getDatabase()
+      
+      const botRow = db
+        .prepare(
+          'SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1',
+        )
+        .get() as { app_id: string; token: string } | undefined
+
+      if (!botRow) {
+        cliLogger.error('No bot credentials found. Run `kimaki` first to set up the bot.')
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      const channelRow = db
+        .prepare(
+          'SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?',
+        )
+        .get(directory, 'text') as { channel_id: string } | undefined
+
+      if (!channelRow) {
+        cliLogger.error(
+          `No Discord channel found for directory: ${directory}\n` +
+            'Run `kimaki --add-channels` to create a channel for this project.',
+        )
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      const s = spinner()
+      s.start('Connecting to Discord...')
+
+      const discordClient = await createDiscordClient()
+
+      await new Promise<void>((resolve, reject) => {
+        discordClient.once(Events.ClientReady, () => {
+          resolve()
+        })
+        discordClient.once(Events.Error, reject)
+        discordClient.login(botRow.token).catch(reject)
+      })
+
+      s.stop('Connected to Discord!')
+
+      const channel = await discordClient.channels.fetch(channelRow.channel_id)
+      if (!channel || channel.type !== ChannelType.GuildText) {
+        cliLogger.error('Could not find the text channel or it is not a text channel')
+        discordClient.destroy()
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      const textChannel = channel as import('discord.js').TextChannel
+
+      s.start('Fetching session from OpenCode...')
+
+      const getClient = await initializeOpencodeForDirectory(directory)
+      const sessionResponse = await getClient().session.get({
+        path: { id: sessionId },
+      })
+
+      if (!sessionResponse.data) {
+        s.stop('Session not found')
+        discordClient.destroy()
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      const session = sessionResponse.data
+      s.stop(`Found session: ${session.title}`)
+
+      s.start('Creating Discord thread...')
+
+      const thread = await textChannel.threads.create({
+        name: `Resume: ${session.title}`.slice(0, 100),
+        autoArchiveDuration: 1440,
+        reason: `Resuming session ${sessionId} from CLI`,
+      })
+
+      db.prepare(
+        'INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)',
+      ).run(thread.id, sessionId)
+
+      s.stop('Created Discord thread!')
+
+      s.start('Loading session messages...')
+
+      const messagesResponse = await getClient().session.messages({
+        path: { id: sessionId },
+      })
+
+      if (!messagesResponse.data) {
+        s.stop('Failed to fetch session messages')
+        discordClient.destroy()
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      const messages = messagesResponse.data
+
+      await thread.send(
+        `📂 **Resumed session:** ${session.title}\n📅 **Created:** ${new Date(session.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`,
+      )
+
+      let messageCount = 0
+      for (const message of messages) {
+        if (message.info.role === 'user') {
+          const userParts = message.parts.filter(
+            (p) => p.type === 'text' && !p.synthetic,
+          )
+          const userTexts = userParts
+            .map((p) => {
+              if (p.type === 'text') {
+                return p.text
+              }
+              return ''
+            })
+            .filter((t) => t.trim())
+
+          const userText = userTexts.join('\n\n')
+          if (userText) {
+            const truncated = userText.length > 1900 ? userText.slice(0, 1900) + '…' : userText
+            await thread.send(`**User:**\n${truncated}`)
+          }
+        } else if (message.info.role === 'assistant') {
+          const textParts = message.parts.filter((p) => p.type === 'text')
+          const texts = textParts
+            .map((p) => {
+              if (p.type === 'text') {
+                return p.text
+              }
+              return ''
+            })
+            .filter((t) => t?.trim())
+
+          if (texts.length > 0) {
+            const combinedText = texts.join('\n\n')
+            const truncated = combinedText.length > 1900 ? combinedText.slice(0, 1900) + '…' : combinedText
+            await thread.send(truncated)
+          }
+        }
+        messageCount++
+      }
+
+      await thread.send(
+        `✅ **Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`,
+      )
+
+      s.stop(`Loaded ${messageCount} messages`)
+
+      const guildId = textChannel.guildId
+      const threadUrl = `https://discord.com/channels/${guildId}/${thread.id}`
+
+      note(
+        `Session "${session.title}" has been sent to Discord!\n\nThread: ${threadUrl}`,
+        '✅ Success',
+      )
+
+      discordClient.destroy()
+      process.exit(0)
+    } catch (error) {
+      cliLogger.error(
+        'Error:',
+        error instanceof Error ? error.message : String(error),
+      )
+      process.exit(EXIT_NO_RESTART)
+    }
+  })
+
+cli
+  .command('install-plugin', 'Install the OpenCode plugin for /send-to-kimaki-discord command')
+  .action(async () => {
+    try {
+      const require = createRequire(import.meta.url)
+      const pluginSrc = require.resolve('./opencode-plugin.ts')
+      const commandSrc = require.resolve('./opencode-command.md')
+
+      const opencodeConfig = path.join(os.homedir(), '.config', 'opencode')
+      const pluginDir = path.join(opencodeConfig, 'plugin')
+      const commandDir = path.join(opencodeConfig, 'command')
+
+      fs.mkdirSync(pluginDir, { recursive: true })
+      fs.mkdirSync(commandDir, { recursive: true })
+
+      const pluginDest = path.join(pluginDir, 'send-to-kimaki-discord.ts')
+      const commandDest = path.join(commandDir, 'send-to-kimaki-discord.md')
+
+      fs.copyFileSync(pluginSrc, pluginDest)
+      fs.copyFileSync(commandSrc, commandDest)
+
+      note(
+        `Plugin: ${pluginDest}\nCommand: ${commandDest}\n\nUse /send-to-kimaki-discord in OpenCode to send the current session to Discord.`,
+        '✅ Installed',
+      )
+
+      process.exit(0)
+    } catch (error) {
+      cliLogger.error(
+        'Error:',
+        error instanceof Error ? error.message : String(error),
+      )
+      process.exit(EXIT_NO_RESTART)
+    }
+  })
+
 cli.help()
 cli.parse()

package/src/opencode-command.md

@@ -0,0 +1,4 @@
+---
+description: Create Discord thread for current session
+---
+Creating Discord thread for this session...

package/src/opencode-plugin.ts

@@ -0,0 +1,75 @@
+/**
+ * Kimaki Discord Plugin for OpenCode
+ *
+ * Adds /send-to-kimaki-discord command that sends the current session to Discord.
+ *
+ * Installation:
+ *   kimaki install-plugin
+ *
+ * Use in OpenCode TUI:
+ *   /send-to-kimaki-discord
+ */
+
+import type { Plugin } from '@opencode-ai/plugin'
+
+export const KimakiDiscordPlugin: Plugin = async ({
+  client,
+  $,
+  directory,
+}) => {
+  return {
+    event: async ({ event }) => {
+      if (event.type !== 'command.executed') {
+        return
+      }
+
+      const { name, sessionID } = event.properties as {
+        name: string
+        sessionID: string
+      }
+
+      if (name !== 'send-to-kimaki-discord') {
+        return
+      }
+
+      if (!sessionID) {
+        await client.tui.showToast({
+          body: { message: 'No session ID available', variant: 'error' },
+        })
+        return
+      }
+
+      await client.tui.showToast({
+        body: { message: 'Creating Discord thread...', variant: 'info' },
+      })
+
+      try {
+        const result =
+          await $`npx -y kimaki send-to-discord ${sessionID} -d ${directory}`.text()
+
+        const urlMatch = result.match(/https:\/\/discord\.com\/channels\/\S+/)
+        const url = urlMatch ? urlMatch[0] : null
+
+        await client.tui.showToast({
+          body: {
+            message: url ? `Sent to Discord: ${url}` : 'Session sent to Discord',
+            variant: 'success',
+          },
+        })
+      } catch (error: any) {
+        const message =
+          error.stderr?.toString().trim() ||
+          error.stdout?.toString().trim() ||
+          error.message ||
+          String(error)
+
+        await client.tui.showToast({
+          body: {
+            message: `Failed: ${message.slice(0, 100)}`,
+            variant: 'error',
+          },
+        })
+      }
+    },
+  }
+}

package/src/voice.ts

@@ -42,7 +42,17 @@ export async function transcribeAudio({
     }
 
     // Build the transcription prompt
-    let transcriptionPrompt = `Please transcribe this audio file accurately. Here is some relevant information and filenames that may be present in the audio:\n<context>\n${prompt}\n</context>\n`
+    let transcriptionPrompt = `Transcribe this audio accurately. The transcription will be sent to a coding agent (like Claude Code) to execute programming tasks.
+
+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.
+
+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.
+
+Here are relevant filenames and context that may appear in the audio:
+<context>
+${prompt}
+</context>
+`
     if (language) {
       transcriptionPrompt += `\nThe audio is in ${language}.`
     }