@brianli/kimaki 0.4.72-brianli.1

package/src/commands/unset-model.ts

@@ -0,0 +1,189 @@
+// /unset-model-override command - Remove model overrides and use default instead.
+
+import {
+  ChatInputCommandInteraction,
+  ChannelType,
+  type ThreadChannel,
+  type TextChannel,
+  MessageFlags,
+} from 'discord.js'
+import {
+  getChannelModel,
+  getSessionModel,
+  getThreadSession,
+  clearSessionModel,
+} from '../database.js'
+import { getPrisma } from '../db.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
+import { abortAndRetrySession } from '../session-handler.js'
+import { getCurrentModelInfo } from './model.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const unsetModelLogger = createLogger(LogPrefix.MODEL)
+
+function formatModelSource(type: string, agentName?: string): string {
+  switch (type) {
+    case 'session':
+      return 'session override'
+    case 'agent':
+      return `agent "${agentName}"`
+    case 'channel':
+      return 'channel override'
+    case 'global':
+      return 'global default'
+    case 'opencode-config':
+    case 'opencode-recent':
+    case 'opencode-provider-default':
+      return 'opencode default'
+    default:
+      return 'none'
+  }
+}
+
+/**
+ * Handle the /unset-model-override slash command.
+ * In thread: clears session override if exists, otherwise channel override.
+ * In channel: clears channel override.
+ */
+export async function handleUnsetModelCommand({
+  interaction,
+  appId,
+}: {
+  interaction: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  unsetModelLogger.log('[UNSET-MODEL] handleUnsetModelCommand called')
+
+  await interaction.deferReply({ flags: MessageFlags.Ephemeral })
+
+  const channel = interaction.channel
+
+  if (!channel) {
+    await interaction.editReply({
+      content: 'This command can only be used in a channel',
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  let projectDirectory: string | undefined
+  let channelAppId: string | undefined
+  let targetChannelId: string
+  let sessionId: string | undefined
+
+  if (isThread) {
+    const thread = channel as ThreadChannel
+    const textChannel = await resolveTextChannel(thread)
+    const metadata = await getKimakiMetadata(textChannel)
+    projectDirectory = metadata.projectDirectory
+    channelAppId = metadata.channelAppId
+    targetChannelId = textChannel?.id || channel.id
+    sessionId = await getThreadSession(thread.id)
+  } else if (channel.type === ChannelType.GuildText) {
+    const textChannel = channel as TextChannel
+    const metadata = await getKimakiMetadata(textChannel)
+    projectDirectory = metadata.projectDirectory
+    channelAppId = metadata.channelAppId
+    targetChannelId = channel.id
+  } else {
+    await interaction.editReply({
+      content: 'This command can only be used in text channels or threads',
+    })
+    return
+  }
+
+  if (channelAppId && channelAppId !== appId) {
+    await interaction.editReply({
+      content: 'This channel is not configured for this bot',
+    })
+    return
+  }
+
+  if (!projectDirectory) {
+    await interaction.editReply({
+      content: 'This channel is not configured with a project directory',
+    })
+    return
+  }
+
+  const effectiveAppId = channelAppId || appId
+
+  // Check what overrides exist
+  const [sessionPref, channelPref] = await Promise.all([
+    sessionId ? getSessionModel(sessionId) : Promise.resolve(undefined),
+    getChannelModel(targetChannelId),
+  ])
+
+  let clearedType: 'session' | 'channel' | null = null
+  let clearedModel: string | undefined
+
+  if (isThread && sessionId && sessionPref) {
+    // In thread with session override: clear session
+    await clearSessionModel(sessionId)
+    clearedType = 'session'
+    clearedModel = sessionPref.modelId
+    unsetModelLogger.log(`[UNSET-MODEL] Cleared session model for ${sessionId}`)
+  } else if (channelPref) {
+    // Clear channel override
+    const prisma = await getPrisma()
+    await prisma.channel_models.deleteMany({
+      where: { channel_id: targetChannelId },
+    })
+    clearedType = 'channel'
+    clearedModel = channelPref.modelId
+    unsetModelLogger.log(
+      `[UNSET-MODEL] Cleared channel model for ${targetChannelId}`,
+    )
+  } else {
+    await interaction.editReply({
+      content: 'No model override to clear.',
+    })
+    return
+  }
+
+  // Get the new model that will be used
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  let newModelText = 'unknown'
+
+  if (!(getClient instanceof Error)) {
+    const newModelInfo = await getCurrentModelInfo({
+      sessionId,
+      channelId: targetChannelId,
+      appId: effectiveAppId,
+      getClient,
+    })
+
+    newModelText =
+      newModelInfo.type === 'none'
+        ? 'none'
+        : `\`${newModelInfo.model}\` (${formatModelSource(newModelInfo.type, 'agentName' in newModelInfo ? newModelInfo.agentName : undefined)})`
+  }
+
+  // Check if there's a running request and abort+retry with new model (only for session changes in threads)
+  let retried = false
+  if (isThread && clearedType === 'session' && sessionId) {
+    const thread = channel as ThreadChannel
+    retried = await abortAndRetrySession({
+      sessionId,
+      thread,
+      projectDirectory,
+      appId: effectiveAppId,
+      channelId: targetChannelId,
+    })
+  }
+
+  const clearedTypeText = clearedType === 'session' ? 'Session' : 'Channel'
+  const retriedText = retried
+    ? '\n_Retrying current request with new model..._'
+    : ''
+
+  await interaction.editReply({
+    content: `${clearedTypeText} model override removed.\n**Was:** \`${clearedModel}\`\n**Now using:** ${newModelText}${retriedText}`,
+  })
+}

package/src/commands/upgrade.ts

@@ -0,0 +1,52 @@
+// /upgrade-and-restart command - Upgrade kimaki to the latest version and restart the bot.
+// Checks npm for a newer version, installs it globally, then spawns a new kimaki process.
+// The new process kills the old one on startup (kimaki's single-instance lock).
+
+import type { CommandContext } from './types.js'
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { getCurrentVersion, upgrade } from '../upgrade.js'
+import { spawn } from 'node:child_process'
+
+const logger = createLogger(LogPrefix.CLI)
+
+export async function handleUpgradeAndRestartCommand({
+  command,
+}: CommandContext): Promise<void> {
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  logger.log('[UPGRADE] /upgrade-and-restart triggered')
+
+  try {
+    const currentVersion = getCurrentVersion()
+    const newVersion = await upgrade()
+
+    if (!newVersion) {
+      await command.editReply({
+        content: `Already on latest version: **v${currentVersion}**`,
+      })
+      return
+    }
+
+    await command.editReply({
+      content: `Upgraded kimaki **v${currentVersion}** -> **v${newVersion}**. Restarting bot...`,
+    })
+
+    // Spawning bare `kimaki` works even if the user originally ran via npx/bunx:
+    // `npm i -g kimaki@latest` creates a global bin link, and npx resolves
+    // local -> global -> cache -> registry, so it prefers the global install.
+    // bunx shares the same global cache, so it also picks up the new version.
+    const child = spawn('kimaki', process.argv.slice(2), {
+      shell: true,
+      stdio: 'ignore',
+      detached: true,
+    })
+    child.unref()
+    logger.debug('Started new background kimaki')
+  } catch (error) {
+    logger.error('[UPGRADE] Failed:', error)
+    await command.editReply({
+      content: `Upgrade failed: ${error instanceof Error ? error.message : String(error)}`,
+    })
+  }
+}

package/src/commands/user-command.ts

@@ -0,0 +1,193 @@
+// User-defined OpenCode command handler.
+// Handles slash commands that map to user-configured commands in opencode.json.
+
+import type { CommandContext, CommandHandler } from './types.js'
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import { handleOpencodeSession } from '../session-handler.js'
+import { sendThreadMessage, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { getChannelDirectory, getThreadSession } from '../database.js'
+import { registeredUserCommands } from '../config.js'
+import fs from 'node:fs'
+
+const userCommandLogger = createLogger(LogPrefix.USER_CMD)
+
+export const handleUserCommand: CommandHandler = async ({
+  command,
+  appId,
+}: CommandContext) => {
+  const discordCommandName = command.commandName
+  // Look up the original OpenCode command name from the mapping populated at registration.
+  // The sanitized Discord name is lossy (e.g. foo:bar → foo-bar), so stripping -cmd
+  // would give the wrong name for commands with special characters.
+  const sanitizedBase = discordCommandName.replace(/-cmd$/, '')
+  const registered = registeredUserCommands.find(
+    (c) => c.discordName === sanitizedBase,
+  )
+  const commandName = registered?.name || sanitizedBase
+  const args = command.options.getString('arguments') || ''
+
+  userCommandLogger.log(
+    `Executing /${commandName} (from /${discordCommandName}) argsLength=${args.length}`,
+  )
+
+  const channel = command.channel
+
+  userCommandLogger.log(
+    `Channel info: type=${channel?.type}, id=${channel?.id}, isNull=${channel === null}`,
+  )
+
+  const isThread =
+    channel &&
+    [
+      ChannelType.PublicThread,
+      ChannelType.PrivateThread,
+      ChannelType.AnnouncementThread,
+    ].includes(channel.type)
+
+  const isTextChannel = channel?.type === ChannelType.GuildText
+
+  if (!channel || (!isTextChannel && !isThread)) {
+    await command.reply({
+      content: 'This command can only be used in text channels or threads',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  let projectDirectory: string | undefined
+  let channelAppId: string | undefined
+  let textChannel: TextChannel | null = null
+  let thread: ThreadChannel | null = null
+
+  if (isThread) {
+    // Running in an existing thread - get project directory from parent channel
+    thread = channel as ThreadChannel
+    textChannel = thread.parent as TextChannel | null
+
+    // Verify this thread has an existing session
+    const sessionId = await getThreadSession(thread.id)
+
+    if (!sessionId) {
+      await command.reply({
+        content:
+          'This thread does not have an active session. Use this command in a project channel to create a new thread.',
+        flags: MessageFlags.Ephemeral,
+      })
+      return
+    }
+
+    if (textChannel) {
+      const channelConfig = await getChannelDirectory(textChannel.id)
+      projectDirectory = channelConfig?.directory
+      channelAppId = channelConfig?.appId || undefined
+    }
+  } else {
+    // Running in a text channel - will create a new thread
+    textChannel = channel as TextChannel
+
+    const channelConfig = await getChannelDirectory(textChannel.id)
+    projectDirectory = channelConfig?.directory
+    channelAppId = channelConfig?.appId || undefined
+  }
+
+  if (channelAppId && channelAppId !== appId) {
+    await command.reply({
+      content: 'This channel is not configured for this bot',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  if (!projectDirectory) {
+    await command.reply({
+      content: 'This channel is not configured with a project directory',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  if (!fs.existsSync(projectDirectory)) {
+    await command.reply({
+      content: `Directory does not exist: ${projectDirectory}`,
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  await command.deferReply({ ephemeral: false })
+
+  try {
+    // Use the dedicated session.command API instead of formatting as text prompt
+    const commandPayload = { name: commandName, arguments: args }
+
+    if (isThread && thread) {
+      // Running in existing thread - just send the command
+      await command.editReply(`Running /${commandName}...`)
+
+      await handleOpencodeSession({
+        prompt: '', // Not used when command is set
+        thread,
+        projectDirectory,
+        channelId: textChannel?.id,
+        command: commandPayload,
+        appId,
+      })
+    } else if (textChannel) {
+      // Running in text channel - create a new thread
+      const starterMessage = await textChannel.send({
+        content: `**/${commandName}**`,
+        flags: SILENT_MESSAGE_FLAGS,
+      })
+
+      const threadName = `/${commandName}`
+      const newThread = await starterMessage.startThread({
+        name: threadName.slice(0, 100),
+        autoArchiveDuration: 1440,
+        reason: `OpenCode command: ${commandName}`,
+      })
+
+      // Add user to thread so it appears in their sidebar
+      await newThread.members.add(command.user.id)
+
+      if (args) {
+        const argsPreview =
+          args.length > 1800 ? `${args.slice(0, 1800)}\n... truncated` : args
+        await sendThreadMessage(newThread, `Args: ${argsPreview}`)
+      }
+
+      await command.editReply(
+        `Started /${commandName} in ${newThread.toString()}`,
+      )
+
+      await handleOpencodeSession({
+        prompt: '', // Not used when command is set
+        thread: newThread,
+        projectDirectory,
+        channelId: textChannel.id,
+        command: commandPayload,
+        appId,
+      })
+    }
+  } catch (error) {
+    userCommandLogger.error(`Error executing /${commandName}:`, error)
+
+    const errorMessage = error instanceof Error ? error.message : String(error)
+
+    if (command.deferred) {
+      await command.editReply({
+        content: `Failed to execute /${commandName}: ${errorMessage}`,
+      })
+    } else {
+      await command.reply({
+        content: `Failed to execute /${commandName}: ${errorMessage}`,
+        flags: MessageFlags.Ephemeral,
+      })
+    }
+  }
+}

package/src/commands/verbosity.ts

@@ -0,0 +1,88 @@
+// /verbosity command.
+// Sets the output verbosity level for sessions in a channel.
+// 'text-and-essential-tools' (default): shows text and essential tools (edits, custom MCP tools)
+// 'tools-and-text': shows all output including tool executions
+// 'text-only': only shows text responses (⬥ diamond parts)
+
+import {
+  ChatInputCommandInteraction,
+  MessageFlags,
+  ChannelType,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import {
+  getChannelVerbosity,
+  setChannelVerbosity,
+  type VerbosityLevel,
+} from '../database.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const verbosityLogger = createLogger(LogPrefix.VERBOSITY)
+
+/**
+ * Handle the /verbosity slash command.
+ * Sets output verbosity for the channel (applies immediately, even mid-session).
+ */
+export async function handleVerbosityCommand({
+  command,
+  appId,
+}: {
+  command: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  verbosityLogger.log('[VERBOSITY] Command called')
+
+  const channel = command.channel
+  if (!channel) {
+    await command.reply({
+      content: 'Could not determine channel.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  // Get the parent channel ID (for threads, use parent; for text channels, use self)
+  const channelId = (() => {
+    if (channel.type === ChannelType.GuildText) {
+      return channel.id
+    }
+    if (
+      channel.type === ChannelType.PublicThread ||
+      channel.type === ChannelType.PrivateThread ||
+      channel.type === ChannelType.AnnouncementThread
+    ) {
+      return (channel as ThreadChannel).parentId || channel.id
+    }
+    return channel.id
+  })()
+
+  const level = command.options.getString('level', true) as VerbosityLevel
+  const currentLevel = await getChannelVerbosity(channelId)
+
+  if (currentLevel === level) {
+    await command.reply({
+      content: `Verbosity is already set to **${level}** for this channel.`,
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  await setChannelVerbosity(channelId, level)
+  verbosityLogger.log(`[VERBOSITY] Set channel ${channelId} to ${level}`)
+
+  const description = (() => {
+    if (level === 'text-only') {
+      return 'Only text responses will be shown. Tool executions, status messages, and thinking will be hidden.'
+    }
+    if (level === 'text-and-essential-tools') {
+      return 'Text responses and essential tools (edits, custom MCP tools) will be shown. Read, search, and navigation tools will be hidden.'
+    }
+    return 'All output will be shown, including tool executions and status messages.'
+  })()
+
+  await command.reply({
+    content: `Verbosity set to **${level}** for this channel.\n${description}\nThis is a per-channel setting and applies immediately, including any active sessions.`,
+    flags: MessageFlags.Ephemeral,
+  })
+}

package/src/commands/worktree-settings.ts

@@ -0,0 +1,79 @@
+// /toggle-worktrees command.
+// Allows per-channel opt-in for automatic worktree creation,
+// as an alternative to the global --use-worktrees CLI flag.
+
+import {
+  ChatInputCommandInteraction,
+  MessageFlags,
+  ChannelType,
+  type TextChannel,
+} from 'discord.js'
+import {
+  getChannelWorktreesEnabled,
+  setChannelWorktreesEnabled,
+} from '../database.js'
+import { getKimakiMetadata } from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const worktreeSettingsLogger = createLogger(LogPrefix.WORKTREE)
+
+/**
+ * Handle the /toggle-worktrees slash command.
+ * Toggles automatic worktree creation for new sessions in this channel.
+ */
+export async function handleToggleWorktreesCommand({
+  command,
+  appId,
+}: {
+  command: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  worktreeSettingsLogger.log('[TOGGLE_WORKTREES] Command called')
+
+  const channel = command.channel
+
+  if (!channel || channel.type !== ChannelType.GuildText) {
+    await command.reply({
+      content: 'This command can only be used in text channels (not threads).',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const textChannel = channel as TextChannel
+  const metadata = await getKimakiMetadata(textChannel)
+
+  if (metadata.channelAppId && metadata.channelAppId !== appId) {
+    await command.reply({
+      content: 'This channel is configured for a different bot.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  if (!metadata.projectDirectory) {
+    await command.reply({
+      content:
+        'This channel is not configured with a project directory.\nUse `/add-project` to set up this channel.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const wasEnabled = await getChannelWorktreesEnabled(textChannel.id)
+  const nextEnabled = !wasEnabled
+  await setChannelWorktreesEnabled(textChannel.id, nextEnabled)
+
+  const nextLabel = nextEnabled ? 'enabled' : 'disabled'
+
+  worktreeSettingsLogger.log(
+    `[TOGGLE_WORKTREES] ${nextLabel.toUpperCase()} for channel ${textChannel.id}`,
+  )
+
+  await command.reply({
+    content: nextEnabled
+      ? `Worktrees **enabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will now automatically create git worktrees.\n\nNew setting for **#${textChannel.name}**: **enabled**.`
+      : `Worktrees **disabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will use the main project directory.\n\nNew setting for **#${textChannel.name}**: **disabled**.`,
+    flags: MessageFlags.Ephemeral,
+  })
+}