kimaki 0.4.24 → 0.4.25

package/src/commands/add-project.ts

@@ -0,0 +1,138 @@
+// /add-project command - Create Discord channels for an existing OpenCode project.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import type { CommandContext, AutocompleteContext } from './types.js'
+import { getDatabase } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { createProjectChannels } from '../channel-management.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('ADD-PROJECT')
+
+export async function handleAddProjectCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  await command.deferReply({ ephemeral: false })
+
+  const projectId = command.options.getString('project', true)
+  const guild = command.guild
+
+  if (!guild) {
+    await command.editReply('This command can only be used in a guild')
+    return
+  }
+
+  try {
+    const currentDir = process.cwd()
+    const getClient = await initializeOpencodeForDirectory(currentDir)
+
+    const projectsResponse = await getClient().project.list({})
+    if (!projectsResponse.data) {
+      await command.editReply('Failed to fetch projects')
+      return
+    }
+
+    const project = projectsResponse.data.find((p) => p.id === projectId)
+
+    if (!project) {
+      await command.editReply('Project not found')
+      return
+    }
+
+    const directory = project.worktree
+
+    if (!fs.existsSync(directory)) {
+      await command.editReply(`Directory does not exist: ${directory}`)
+      return
+    }
+
+    const db = getDatabase()
+    const existingChannel = db
+      .prepare(
+        'SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?',
+      )
+      .get(directory, 'text') as { channel_id: string } | undefined
+
+    if (existingChannel) {
+      await command.editReply(
+        `A channel already exists for this directory: <#${existingChannel.channel_id}>`,
+      )
+      return
+    }
+
+    const { textChannelId, voiceChannelId, channelName } =
+      await createProjectChannels({
+        guild,
+        projectDirectory: directory,
+        appId,
+      })
+
+    await command.editReply(
+      `✅ Created channels for project:\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n📁 Directory: \`${directory}\``,
+    )
+
+    logger.log(`Created channels for project ${channelName} at ${directory}`)
+  } catch (error) {
+    logger.error('[ADD-PROJECT] Error:', error)
+    await command.editReply(
+      `Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}
+
+export async function handleAddProjectAutocomplete({
+  interaction,
+  appId,
+}: AutocompleteContext): Promise<void> {
+  const focusedValue = interaction.options.getFocused()
+
+  try {
+    const currentDir = process.cwd()
+    const getClient = await initializeOpencodeForDirectory(currentDir)
+
+    const projectsResponse = await getClient().project.list({})
+    if (!projectsResponse.data) {
+      await interaction.respond([])
+      return
+    }
+
+    const db = getDatabase()
+    const existingDirs = db
+      .prepare(
+        'SELECT DISTINCT directory FROM channel_directories WHERE channel_type = ?',
+      )
+      .all('text') as { directory: string }[]
+    const existingDirSet = new Set(existingDirs.map((row) => row.directory))
+
+    const availableProjects = projectsResponse.data.filter(
+      (project) => !existingDirSet.has(project.worktree),
+    )
+
+    const projects = availableProjects
+      .filter((project) => {
+        const baseName = path.basename(project.worktree)
+        const searchText = `${baseName} ${project.worktree}`.toLowerCase()
+        return searchText.includes(focusedValue.toLowerCase())
+      })
+      .sort((a, b) => {
+        const aTime = a.time.initialized || a.time.created
+        const bTime = b.time.initialized || b.time.created
+        return bTime - aTime
+      })
+      .slice(0, 25)
+      .map((project) => {
+        const name = `${path.basename(project.worktree)} (${project.worktree})`
+        return {
+          name: name.length > 100 ? name.slice(0, 99) + '…' : name,
+          value: project.id,
+        }
+      })
+
+    await interaction.respond(projects)
+  } catch (error) {
+    logger.error('[AUTOCOMPLETE] Error fetching projects:', error)
+    await interaction.respond([])
+  }
+}

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,
@@ -8,10 +10,11 @@ import {
   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')
@@ -209,7 +212,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,10 @@ 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 { createLogger } from '../logger.js'
 
 const modelLogger = createLogger('MODEL')
 
@@ -25,7 +27,7 @@ const pendingModelContexts = new Map<string, {
   providerName?: string
 }>()
 
-type ProviderInfo = {
+export type ProviderInfo = {
   id: string
   name: string
   models: Record<

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}`,
+  )
+}