kimaki 0.4.24 → 0.4.26

package/src/commands/create-new-project.ts

@@ -0,0 +1,111 @@
+// /create-new-project command - Create a new project folder, initialize git, and start a session.
+
+import { ChannelType, type TextChannel } from 'discord.js'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import type { CommandContext } from './types.js'
+import { createProjectChannels } from '../channel-management.js'
+import { handleOpencodeSession } from '../session-handler.js'
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('CREATE-NEW-PROJECT')
+
+export async function handleCreateNewProjectCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  await command.deferReply({ ephemeral: false })
+
+  const projectName = command.options.getString('name', true)
+  const guild = command.guild
+  const channel = command.channel
+
+  if (!guild) {
+    await command.editReply('This command can only be used in a guild')
+    return
+  }
+
+  if (!channel || channel.type !== ChannelType.GuildText) {
+    await command.editReply('This command can only be used in a text channel')
+    return
+  }
+
+  const sanitizedName = projectName
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 100)
+
+  if (!sanitizedName) {
+    await command.editReply('Invalid project name')
+    return
+  }
+
+  const kimakiDir = path.join(os.homedir(), 'kimaki')
+  const projectDirectory = path.join(kimakiDir, sanitizedName)
+
+  try {
+    if (!fs.existsSync(kimakiDir)) {
+      fs.mkdirSync(kimakiDir, { recursive: true })
+      logger.log(`Created kimaki directory: ${kimakiDir}`)
+    }
+
+    if (fs.existsSync(projectDirectory)) {
+      await command.editReply(
+        `Project directory already exists: ${projectDirectory}`,
+      )
+      return
+    }
+
+    fs.mkdirSync(projectDirectory, { recursive: true })
+    logger.log(`Created project directory: ${projectDirectory}`)
+
+    const { execSync } = await import('node:child_process')
+    execSync('git init', { cwd: projectDirectory, stdio: 'pipe' })
+    logger.log(`Initialized git in: ${projectDirectory}`)
+
+    const { textChannelId, voiceChannelId, channelName } =
+      await createProjectChannels({
+        guild,
+        projectDirectory,
+        appId,
+      })
+
+    const textChannel = (await guild.channels.fetch(
+      textChannelId,
+    )) as TextChannel
+
+    await command.editReply(
+      `✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n\n_Starting session..._`,
+    )
+
+    const starterMessage = await textChannel.send({
+      content: `🚀 **New project initialized**\n📁 \`${projectDirectory}\``,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+
+    const thread = await starterMessage.startThread({
+      name: `Init: ${sanitizedName}`,
+      autoArchiveDuration: 1440,
+      reason: 'New project session',
+    })
+
+    await handleOpencodeSession({
+      prompt:
+        'The project was just initialized. Say hi and ask what the user wants to build.',
+      thread,
+      projectDirectory,
+      channelId: textChannel.id,
+    })
+
+    logger.log(`Created new project ${channelName} at ${projectDirectory}`)
+  } catch (error) {
+    logger.error('[CREATE-NEW-PROJECT] Error:', error)
+    await command.editReply(
+      `Failed to create new project: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}

package/src/{fork.ts → commands/fork.ts}

@@ -1,3 +1,5 @@
+// /fork command - Fork the session from a past user message.
+
 import {
   ChatInputCommandInteraction,
   StringSelectMenuInteraction,
@@ -7,11 +9,11 @@ import {
   ThreadAutoArchiveDuration,
   type ThreadChannel,
 } from 'discord.js'
-import type { TextPart } from '@opencode-ai/sdk'
-import { getDatabase } from './database.js'
-import { initializeOpencodeForDirectory } from './opencode.js'
-import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from './discord-utils.js'
-import { createLogger } from './logger.js'
+import { getDatabase } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from '../discord-utils.js'
+import { collectLastAssistantParts } from '../message-formatting.js'
+import { createLogger } from '../logger.js'
 
 const sessionLogger = createLogger('SESSION')
 const forkLogger = createLogger('FORK')
@@ -97,7 +99,7 @@ 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 TextPart | undefined
+      const textPart = m.parts.find((p) => p.type === 'text') as { type: 'text'; text: string } | undefined
       const preview = textPart?.text?.slice(0, 80) || '(no text)'
       const label = `${index + 1}. ${preview}${preview.length >= 80 ? '...' : ''}`
 
@@ -209,7 +211,38 @@ export async function handleForkSelectMenu(interaction: StringSelectMenuInteract
 
     await sendThreadMessage(
       thread,
-      `**Forked session created!**\nFrom: \`${sessionId}\`\nNew session: \`${forkedSession.id}\`\n\nYou can now continue the conversation from this point.`
+      `**Forked session created!**\nFrom: \`${sessionId}\`\nNew session: \`${forkedSession.id}\``,
+    )
+
+    // Fetch and display the last assistant messages from the forked session
+    const messagesResponse = await getClient().session.messages({
+      path: { id: forkedSession.id },
+    })
+
+    if (messagesResponse.data) {
+      const { partIds, content } = collectLastAssistantParts({
+        messages: messagesResponse.data,
+      })
+
+      if (content.trim()) {
+        const discordMessage = await sendThreadMessage(thread, content)
+
+        // Store part-message mappings for future reference
+        const stmt = getDatabase().prepare(
+          'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
+        )
+        const transaction = getDatabase().transaction((ids: string[]) => {
+          for (const partId of ids) {
+            stmt.run(partId, discordMessage.id, thread.id)
+          }
+        })
+        transaction(partIds)
+      }
+    }
+
+    await sendThreadMessage(
+      thread,
+      `You can now continue the conversation from this point.`,
     )
 
     await interaction.editReply(

package/src/{model-command.ts → commands/model.ts}

@@ -1,3 +1,5 @@
+// /model command - Set the preferred model for this channel or session.
+
 import {
   ChatInputCommandInteraction,
   StringSelectMenuInteraction,
@@ -8,10 +10,11 @@ import {
   type TextChannel,
 } from 'discord.js'
 import crypto from 'node:crypto'
-import { getDatabase, setChannelModel, setSessionModel, runModelMigrations } from './database.js'
-import { initializeOpencodeForDirectory } from './opencode.js'
-import { resolveTextChannel, getKimakiMetadata } from './discord-utils.js'
-import { createLogger } from './logger.js'
+import { getDatabase, setChannelModel, setSessionModel, runModelMigrations } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
+import { abortAndRetrySession } from '../session-handler.js'
+import { createLogger } from '../logger.js'
 
 const modelLogger = createLogger('MODEL')
 
@@ -23,9 +26,10 @@ const pendingModelContexts = new Map<string, {
   isThread: boolean
   providerId?: string
   providerName?: string
+  thread?: ThreadChannel
 }>()
 
-type ProviderInfo = {
+export type ProviderInfo = {
   id: string
   name: string
   models: Record<
@@ -154,6 +158,7 @@ export async function handleModelCommand({
       channelId: targetChannelId,
       sessionId: sessionId,
       isThread: isThread,
+      thread: isThread ? (channel as ThreadChannel) : undefined,
     }
     const contextHash = crypto.randomBytes(8).toString('hex')
     pendingModelContexts.set(contextHash, context)
@@ -353,10 +358,27 @@ export async function handleModelSelectMenu(
       setSessionModel(context.sessionId, fullModelId)
       modelLogger.log(`Set model ${fullModelId} for session ${context.sessionId}`)
 
-      await interaction.editReply({
-        content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\``,
-        components: [],
-      })
+      // Check if there's a running request and abort+retry with new model
+      let retried = false
+      if (context.thread) {
+        retried = await abortAndRetrySession({
+          sessionId: context.sessionId,
+          thread: context.thread,
+          projectDirectory: context.dir,
+        })
+      }
+
+      if (retried) {
+        await interaction.editReply({
+          content: `Model changed for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\`\n\n_Retrying current request with new model..._`,
+          components: [],
+        })
+      } else {
+        await interaction.editReply({
+          content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\``,
+          components: [],
+        })
+      }
     } else {
       // Store for channel
       setChannelModel(context.channelId, fullModelId)

package/src/commands/permissions.ts

@@ -0,0 +1,146 @@
+// Permission commands - /accept, /accept-always, /reject
+
+import { ChannelType } from 'discord.js'
+import type { CommandContext } from './types.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { pendingPermissions } from '../session-handler.js'
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('PERMISSIONS')
+
+export async function handleAcceptCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const scope = command.commandName === 'accept-always' ? 'always' : 'once'
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  if (!isThread) {
+    await command.reply({
+      content: 'This command can only be used in a thread with an active session',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const pending = pendingPermissions.get(channel.id)
+  if (!pending) {
+    await command.reply({
+      content: 'No pending permission request in this thread',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(pending.directory)
+    await getClient().postSessionIdPermissionsPermissionId({
+      path: {
+        id: pending.permission.sessionID,
+        permissionID: pending.permission.id,
+      },
+      body: {
+        response: scope,
+      },
+    })
+
+    pendingPermissions.delete(channel.id)
+    const msg =
+      scope === 'always'
+        ? `✅ Permission **accepted** (auto-approve similar requests)`
+        : `✅ Permission **accepted**`
+    await command.reply({ content: msg, flags: SILENT_MESSAGE_FLAGS })
+    logger.log(`Permission ${pending.permission.id} accepted with scope: ${scope}`)
+  } catch (error) {
+    logger.error('[ACCEPT] Error:', error)
+    await command.reply({
+      content: `Failed to accept permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+  }
+}
+
+export async function handleRejectCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  if (!isThread) {
+    await command.reply({
+      content: 'This command can only be used in a thread with an active session',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const pending = pendingPermissions.get(channel.id)
+  if (!pending) {
+    await command.reply({
+      content: 'No pending permission request in this thread',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(pending.directory)
+    await getClient().postSessionIdPermissionsPermissionId({
+      path: {
+        id: pending.permission.sessionID,
+        permissionID: pending.permission.id,
+      },
+      body: {
+        response: 'reject',
+      },
+    })
+
+    pendingPermissions.delete(channel.id)
+    await command.reply({
+      content: `❌ Permission **rejected**`,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    logger.log(`Permission ${pending.permission.id} rejected`)
+  } catch (error) {
+    logger.error('[REJECT] Error:', error)
+    await command.reply({
+      content: `Failed to reject permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+  }
+}

package/src/commands/queue.ts

@@ -0,0 +1,181 @@
+// Queue commands - /queue, /clear-queue
+
+import { ChannelType, type ThreadChannel } from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getDatabase } from '../database.js'
+import {
+  resolveTextChannel,
+  getKimakiMetadata,
+  sendThreadMessage,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import {
+  handleOpencodeSession,
+  abortControllers,
+  addToQueue,
+  getQueueLength,
+  clearQueue,
+} from '../session-handler.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('QUEUE')
+
+export async function handleQueueCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const message = command.options.getString('message', true)
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  if (!isThread) {
+    await command.reply({
+      content: 'This command can only be used in a thread with an active session',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const row = getDatabase()
+    .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+    .get(channel.id) as { session_id: string } | undefined
+
+  if (!row?.session_id) {
+    await command.reply({
+      content: 'No active session in this thread. Send a message directly instead.',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  // Check if there's an active request running
+  const hasActiveRequest = abortControllers.has(row.session_id)
+
+  if (!hasActiveRequest) {
+    // No active request, send immediately
+    const textChannel = await resolveTextChannel(channel as ThreadChannel)
+    const { projectDirectory } = getKimakiMetadata(textChannel)
+
+    if (!projectDirectory) {
+      await command.reply({
+        content: 'Could not determine project directory',
+        ephemeral: true,
+        flags: SILENT_MESSAGE_FLAGS,
+      })
+      return
+    }
+
+    await command.reply({
+      content: `» **${command.user.displayName}:** ${message.slice(0, 100)}${message.length > 100 ? '...' : ''}`,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+
+    logger.log(
+      `[QUEUE] No active request, sending immediately in thread ${channel.id}`,
+    )
+
+    handleOpencodeSession({
+      prompt: message,
+      thread: channel as ThreadChannel,
+      projectDirectory,
+      channelId: textChannel?.id || channel.id,
+    }).catch(async (e) => {
+      logger.error(`[QUEUE] Failed to send message:`, e)
+      const errorMsg = e instanceof Error ? e.message : String(e)
+      await sendThreadMessage(
+        channel as ThreadChannel,
+        `✗ Failed: ${errorMsg.slice(0, 200)}`,
+      )
+    })
+
+    return
+  }
+
+  // Add to queue
+  const queuePosition = addToQueue({
+    threadId: channel.id,
+    message: {
+      prompt: message,
+      userId: command.user.id,
+      username: command.user.displayName,
+      queuedAt: Date.now(),
+    },
+  })
+
+  await command.reply({
+    content: `✅ Message queued (position: ${queuePosition}). Will be sent after current response.`,
+    ephemeral: true,
+    flags: SILENT_MESSAGE_FLAGS,
+  })
+
+  logger.log(
+    `[QUEUE] User ${command.user.displayName} queued message in thread ${channel.id}`,
+  )
+}
+
+export async function handleClearQueueCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  if (!isThread) {
+    await command.reply({
+      content: 'This command can only be used in a thread',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const queueLength = getQueueLength(channel.id)
+
+  if (queueLength === 0) {
+    await command.reply({
+      content: 'No messages in queue',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  clearQueue(channel.id)
+
+  await command.reply({
+    content: `🗑 Cleared ${queueLength} queued message${queueLength > 1 ? 's' : ''}`,
+    flags: SILENT_MESSAGE_FLAGS,
+  })
+
+  logger.log(
+    `[QUEUE] User ${command.user.displayName} cleared queue in thread ${channel.id}`,
+  )
+}