@brianli/kimaki 0.4.72-brianli.1

package/dist/commands/undo-redo.js

@@ -0,0 +1,159 @@
+// Undo/Redo commands - /undo, /redo
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { getThreadSession } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.UNDO_REDO);
+export async function handleUndoCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | 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',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const { projectDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.editReply(`Failed to undo: ${getClient.message}`);
+        return;
+    }
+    try {
+        // Fetch messages to find the last assistant message
+        const messagesResponse = await getClient().session.messages({
+            sessionID: sessionId,
+        });
+        if (!messagesResponse.data || messagesResponse.data.length === 0) {
+            await command.editReply('No messages to undo');
+            return;
+        }
+        // Find the last assistant message
+        const lastAssistantMessage = [...messagesResponse.data]
+            .reverse()
+            .find((m) => m.info.role === 'assistant');
+        if (!lastAssistantMessage) {
+            await command.editReply('No assistant message to undo');
+            return;
+        }
+        const response = await getClient().session.revert({
+            sessionID: sessionId,
+            messageID: lastAssistantMessage.info.id,
+        });
+        if (response.error) {
+            await command.editReply(`Failed to undo: ${JSON.stringify(response.error)}`);
+            return;
+        }
+        const diffInfo = response.data?.revert?.diff
+            ? `\n\`\`\`diff\n${response.data.revert.diff.slice(0, 1500)}\n\`\`\``
+            : '';
+        await command.editReply(`⏪ **Undone** - reverted last assistant message${diffInfo}`);
+        logger.log(`Session ${sessionId} reverted message ${lastAssistantMessage.info.id}`);
+    }
+    catch (error) {
+        logger.error('[UNDO] Error:', error);
+        await command.editReply(`Failed to undo: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleRedoCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | 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',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const { projectDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.editReply(`Failed to redo: ${getClient.message}`);
+        return;
+    }
+    try {
+        // Check if session has reverted state
+        const sessionResponse = await getClient().session.get({
+            sessionID: sessionId,
+        });
+        if (!sessionResponse.data?.revert) {
+            await command.editReply('Nothing to redo - no previous undo found');
+            return;
+        }
+        const response = await getClient().session.unrevert({
+            sessionID: sessionId,
+        });
+        if (response.error) {
+            await command.editReply(`Failed to redo: ${JSON.stringify(response.error)}`);
+            return;
+        }
+        await command.editReply(`⏩ **Restored** - session back to previous state`);
+        logger.log(`Session ${sessionId} unrevert completed`);
+    }
+    catch (error) {
+        logger.error('[REDO] Error:', error);
+        await command.editReply(`Failed to redo: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/commands/unset-model.js

@@ -0,0 +1,152 @@
+// /unset-model-override command - Remove model overrides and use default instead.
+import { ChatInputCommandInteraction, ChannelType, 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, agentName) {
+    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, }) {
+    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;
+    let channelAppId;
+    let targetChannelId;
+    let sessionId;
+    if (isThread) {
+        const thread = channel;
+        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;
+        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 = null;
+    let clearedModel;
+    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;
+        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/dist/commands/upgrade.js

@@ -0,0 +1,42 @@
+// /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 { 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, }) {
+    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/dist/commands/user-command.js

@@ -0,0 +1,148 @@
+// User-defined OpenCode command handler.
+// Handles slash commands that map to user-configured commands in opencode.json.
+import { ChannelType, MessageFlags, } 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 = async ({ command, appId, }) => {
+    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;
+    let channelAppId;
+    let textChannel = null;
+    let thread = null;
+    if (isThread) {
+        // Running in an existing thread - get project directory from parent channel
+        thread = channel;
+        textChannel = thread.parent;
+        // 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;
+        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/dist/commands/verbosity.js

@@ -0,0 +1,60 @@
+// /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, } from 'discord.js';
+import { getChannelVerbosity, setChannelVerbosity, } 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, }) {
+    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.parentId || channel.id;
+        }
+        return channel.id;
+    })();
+    const level = command.options.getString('level', true);
+    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/dist/commands/worktree-settings.js

@@ -0,0 +1,50 @@
+// /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, } 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, }) {
+    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;
+    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,
+    });
+}