kimaki 0.1.4 → 0.2.0

package/dist/tools.js

@@ -9,12 +9,14 @@ import { formatDistanceToNow } from 'date-fns';
 import { ShareMarkdown } from './markdown.js';
 import pc from 'picocolors';
 import { initializeOpencodeForDirectory } from './discordBot.js';
-export async function getTools({ onMessageCompleted, directory, }) {
+export async function getTools({ onMessageCompleted, onAllSessionsCompleted, directory, }) {
     const getClient = await initializeOpencodeForDirectory(directory);
     const client = getClient();
     const markdownRenderer = new ShareMarkdown(client);
     const providersResponse = await client.config.providers({});
     const providers = providersResponse.data?.providers || [];
+    // Track all active OpenCode sessions
+    const activeSessions = new Set();
     // Helper: get last assistant model for a session (non-summary)
     const getSessionModel = async (sessionId) => {
         const res = await getClient().session.messages({ path: { id: sessionId } });
@@ -41,6 +43,9 @@ export async function getTools({ onMessageCompleted, directory, }) {
             }),
             execute: async ({ sessionId, message }) => {
                 const sessionModel = await getSessionModel(sessionId);
+                // Track this session as active
+                activeSessions.add(sessionId);
+                toolsLogger.log(`Session ${sessionId} started, ${activeSessions.size} active sessions`);
                 // do not await
                 getClient()
                     .session.prompt({
@@ -61,6 +66,14 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         data: response.data,
                         markdown,
                     });
+                    // Remove from active sessions
+                    activeSessions.delete(sessionId);
+                    toolsLogger.log(`Session ${sessionId} completed, ${activeSessions.size} active sessions remaining`);
+                    // Check if all sessions are complete
+                    if (activeSessions.size === 0) {
+                        toolsLogger.log('All sessions completed');
+                        onAllSessionsCompleted?.();
+                    }
                 })
                     .catch((error) => {
                     onMessageCompleted?.({
@@ -68,6 +81,14 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         messageId: '',
                         error,
                     });
+                    // Remove from active sessions even on error
+                    activeSessions.delete(sessionId);
+                    toolsLogger.log(`Session ${sessionId} failed, ${activeSessions.size} active sessions remaining`);
+                    // Check if all sessions are complete
+                    if (activeSessions.size === 0) {
+                        toolsLogger.log('All sessions completed');
+                        onAllSessionsCompleted?.();
+                    }
                 });
                 return {
                     success: true,
@@ -108,32 +129,52 @@ export async function getTools({ onMessageCompleted, directory, }) {
                     if (!session.data) {
                         throw new Error('Failed to create session');
                     }
+                    const newSessionId = session.data.id;
+                    // Track this session as active
+                    activeSessions.add(newSessionId);
+                    toolsLogger.log(`New session ${newSessionId} created, ${activeSessions.size} active sessions`);
                     // do not await
                     getClient()
                         .session.prompt({
-                        path: { id: session.data.id },
+                        path: { id: newSessionId },
                         body: {
                             parts: [{ type: 'text', text: message }],
                         },
                     })
                         .then(async (response) => {
                         const markdown = await markdownRenderer.generate({
-                            sessionID: session.data.id,
+                            sessionID: newSessionId,
                             lastAssistantOnly: true,
                         });
                         onMessageCompleted?.({
-                            sessionId: session.data.id,
+                            sessionId: newSessionId,
                             messageId: '',
                             data: response.data,
                             markdown,
                         });
+                        // Remove from active sessions
+                        activeSessions.delete(newSessionId);
+                        toolsLogger.log(`Session ${newSessionId} completed, ${activeSessions.size} active sessions remaining`);
+                        // Check if all sessions are complete
+                        if (activeSessions.size === 0) {
+                            toolsLogger.log('All sessions completed');
+                            onAllSessionsCompleted?.();
+                        }
                     })
                         .catch((error) => {
                         onMessageCompleted?.({
-                            sessionId: session.data.id,
+                            sessionId: newSessionId,
                             messageId: '',
                             error,
                         });
+                        // Remove from active sessions even on error
+                        activeSessions.delete(newSessionId);
+                        toolsLogger.log(`Session ${newSessionId} failed, ${activeSessions.size} active sessions remaining`);
+                        // Check if all sessions are complete
+                        if (activeSessions.size === 0) {
+                            toolsLogger.log('All sessions completed');
+                            onAllSessionsCompleted?.();
+                        }
                     });
                     return {
                         success: true,

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [

package/src/cli.ts

@@ -35,6 +35,7 @@ import {
 import path from 'node:path'
 import fs from 'node:fs'
 import { createLogger } from './logger.js'
+import { spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
 
 const cliLogger = createLogger('CLI')
 const cli = cac('kimaki')
@@ -142,6 +143,73 @@ async function run({ restart, addChannels }: CliOptions) {
 
   intro('🤖 Discord Bot Setup')
 
+  // Step 0: Check if OpenCode CLI is available
+  const opencodeCheck = spawnSync('which', ['opencode'], { shell: true })
+
+  if (opencodeCheck.status !== 0) {
+    note(
+      'OpenCode CLI is required but not found in your PATH.',
+      '⚠️  OpenCode Not Found',
+    )
+
+    const shouldInstall = await confirm({
+      message: 'Would you like to install OpenCode right now?',
+    })
+
+    if (isCancel(shouldInstall) || !shouldInstall) {
+      cancel('OpenCode CLI is required to run this bot')
+      process.exit(0)
+    }
+
+    const s = spinner()
+    s.start('Installing OpenCode CLI...')
+
+    try {
+      execSync('curl -fsSL https://opencode.ai/install | bash', {
+        stdio: 'inherit',
+        shell: '/bin/bash',
+      })
+      s.stop('OpenCode CLI installed successfully!')
+
+      // The install script adds opencode to PATH via shell configuration
+      // For the current process, we need to check common installation paths
+      const possiblePaths = [
+        `${process.env.HOME}/.local/bin/opencode`,
+        `${process.env.HOME}/.opencode/bin/opencode`,
+        '/usr/local/bin/opencode',
+        '/opt/opencode/bin/opencode',
+      ]
+
+      const installedPath = possiblePaths.find((p) => {
+        try {
+          fs.accessSync(p, fs.constants.F_OK)
+          return true
+        } catch {
+          return false
+        }
+      })
+
+      if (!installedPath) {
+        note(
+          'OpenCode was installed but may not be available in this session.\n' +
+            'Please restart your terminal and run this command again.',
+          '⚠️  Restart Required',
+        )
+        process.exit(0)
+      }
+
+      // For subsequent spawn calls in this session, we can use the full path
+      process.env.OPENCODE_PATH = installedPath
+    } catch (error) {
+      s.stop('Failed to install OpenCode CLI')
+      cliLogger.error(
+        'Installation error:',
+        error instanceof Error ? error.message : String(error),
+      )
+      process.exit(EXIT_NO_RESTART)
+    }
+  }
+
   const db = getDatabase()
   let appId: string
   let token: string
@@ -377,7 +445,7 @@ async function run({ restart, addChannels }: CliOptions) {
   let projects: Project[] = []
 
   try {
-    const projectsResponse = await getClient().project.list()
+    const projectsResponse = await getClient().project.list({})
     if (!projectsResponse.data) {
       throw new Error('Failed to fetch projects')
     }
@@ -436,22 +504,24 @@ async function run({ restart, addChannels }: CliOptions) {
 
       if (guilds.length === 1) {
         targetGuild = guilds[0]!
+        note(`Using server: ${targetGuild.name}`, 'Server Selected')
       } else {
-        const guildId = await text({
-          message: 'Enter the Discord server ID to create channels in:',
-          placeholder: guilds[0]?.id,
-          validate(value) {
-            if (!value) return 'Server ID is required'
-            if (!guilds.find((g) => g.id === value)) return 'Invalid server ID'
-          },
+        const guildSelection = await multiselect({
+          message: 'Select a Discord server to create channels in:',
+          options: guilds.map((guild) => ({
+            value: guild.id,
+            label: `${guild.name} (${guild.memberCount} members)`,
+          })),
+          required: true,
+          maxItems: 1,
         })
 
-        if (isCancel(guildId)) {
+        if (isCancel(guildSelection)) {
           cancel('Setup cancelled')
           process.exit(0)
         }
 
-        targetGuild = guilds.find((g) => g.id === guildId)!
+        targetGuild = guilds.find((g) => g.id === guildSelection[0])!
       }
 
       s.start('Creating Discord channels...')