kimaki 0.4.78 → 0.4.80

package/dist/commands/model.js

@@ -9,6 +9,7 @@ import { getRuntime } from '../session-handler/thread-session-runtime.js';
 import { getThinkingValuesForModel } from '../thinking-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
+import { buildPaginatedOptions, parsePaginationValue } from './paginated-select.js';
 const modelLogger = createLogger(LogPrefix.MODEL);
 // Store context by hash to avoid customId length limits (Discord max: 100 chars).
 // Entries are TTL'd to prevent unbounded growth when users open /model and never
@@ -291,6 +292,7 @@ export async function handleModelCommand({ interaction, appId, }) {
             return `\n**Variant:** \`${cascadeVariant}\``;
         })();
         // Store context with a short hash key to avoid customId length limits.
+        const providerSelectHeader = `**Set Model Preference**\n${currentModelText}${variantText}\nSelect a provider:`;
         const context = {
             dir: projectDirectory,
             channelId: targetChannelId,
@@ -298,12 +300,12 @@ export async function handleModelCommand({ interaction, appId, }) {
             isThread: isThread,
             thread: isThread ? channel : undefined,
             appId,
+            providerSelectHeader,
         };
         const contextHash = crypto.randomBytes(8).toString('hex');
         setModelContext(contextHash, context);
-        const options = [...availableProviders]
+        const allProviderOptions = [...availableProviders]
             .sort((a, b) => a.name.localeCompare(b.name))
-            .slice(0, 25)
             .map((provider) => {
             const modelCount = Object.keys(provider.models || {}).length;
             return {
@@ -312,13 +314,17 @@ export async function handleModelCommand({ interaction, appId, }) {
                 description: `${modelCount} model${modelCount !== 1 ? 's' : ''} available`.slice(0, 100),
             };
         });
+        const { options } = buildPaginatedOptions({
+            allOptions: allProviderOptions,
+            page: 0,
+        });
         const selectMenu = new StringSelectMenuBuilder()
             .setCustomId(`model_provider:${contextHash}`)
             .setPlaceholder('Select a provider')
             .addOptions(options);
         const actionRow = new ActionRowBuilder().addComponents(selectMenu);
         await interaction.editReply({
-            content: `**Set Model Preference**\n${currentModelText}${variantText}\nSelect a provider:`,
+            content: providerSelectHeader,
             components: [actionRow],
         });
     }
@@ -357,6 +363,45 @@ export async function handleProviderSelectMenu(interaction) {
         });
         return;
     }
+    // Handle pagination nav — re-render the same provider select with new page
+    const providerNavPage = parsePaginationValue(selectedProviderId);
+    if (providerNavPage !== undefined) {
+        context.providerPage = providerNavPage;
+        setModelContext(contextHash, context);
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (getClient instanceof Error) {
+            await interaction.editReply({ content: getClient.message, components: [] });
+            return;
+        }
+        const providersResponse = await getClient().provider.list({ directory: context.dir });
+        if (!providersResponse.data) {
+            await interaction.editReply({ content: 'Failed to fetch providers', components: [] });
+            return;
+        }
+        const { all: allProviders, connected } = providersResponse.data;
+        const availableProviders = allProviders.filter((p) => connected.includes(p.id));
+        const allProviderOptions = [...availableProviders]
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map((p) => {
+            const modelCount = Object.keys(p.models || {}).length;
+            return {
+                label: p.name.slice(0, 100),
+                value: p.id,
+                description: `${modelCount} model${modelCount !== 1 ? 's' : ''} available`.slice(0, 100),
+            };
+        });
+        const { options } = buildPaginatedOptions({ allOptions: allProviderOptions, page: providerNavPage });
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`model_provider:${contextHash}`)
+            .setPlaceholder('Select a provider')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: context.providerSelectHeader || `**Set Model Preference**\nSelect a provider:`,
+            components: [actionRow],
+        });
+        return;
+    }
     try {
         const getClient = await initializeOpencodeForDirectory(context.dir);
         if (getClient instanceof Error) {
@@ -398,13 +443,12 @@ export async function handleProviderSelectMenu(interaction) {
             });
             return;
         }
-        // Take first 25 models (most recent since sorted descending)
-        const recentModels = models.slice(0, 25);
         // Update context with provider info and reuse the same hash
         context.providerId = selectedProviderId;
         context.providerName = provider.name;
+        context.modelPage = 0;
         setModelContext(contextHash, context);
-        const options = recentModels.map((model) => {
+        const allModelOptions = models.map((model) => {
             const dateStr = model.releaseDate
                 ? new Date(model.releaseDate).toLocaleDateString()
                 : 'Unknown date';
@@ -414,6 +458,10 @@ export async function handleProviderSelectMenu(interaction) {
                 description: dateStr.slice(0, 100),
             };
         });
+        const { options } = buildPaginatedOptions({
+            allOptions: allModelOptions,
+            page: 0,
+        });
         const selectMenu = new StringSelectMenuBuilder()
             .setCustomId(`model_select:${contextHash}`)
             .setPlaceholder('Select a model')
@@ -460,6 +508,43 @@ export async function handleModelSelectMenu(interaction) {
         });
         return;
     }
+    // Handle pagination nav — re-render the same model select with new page
+    const modelNavPage = parsePaginationValue(selectedModelId);
+    if (modelNavPage !== undefined) {
+        context.modelPage = modelNavPage;
+        setModelContext(contextHash, context);
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (getClient instanceof Error) {
+            await interaction.editReply({ content: getClient.message, components: [] });
+            return;
+        }
+        const providersResponse = await getClient().provider.list({ directory: context.dir });
+        const provider = providersResponse.data?.all.find((p) => p.id === context.providerId);
+        if (!provider) {
+            await interaction.editReply({ content: 'Provider not found', components: [] });
+            return;
+        }
+        const allModelOptions = Object.entries(provider.models || {})
+            .map(([modelId, model]) => ({
+            label: model.name.slice(0, 100),
+            value: modelId,
+            description: (model.release_date
+                ? new Date(model.release_date).toLocaleDateString()
+                : 'Unknown date').slice(0, 100),
+        }))
+            .sort((a, b) => a.label.localeCompare(b.label));
+        const { options } = buildPaginatedOptions({ allOptions: allModelOptions, page: modelNavPage });
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`model_select:${contextHash}`)
+            .setPlaceholder('Select a model')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: `**Set Model Preference**\nProvider: **${context.providerName}**\nSelect a model:`,
+            components: [actionRow],
+        });
+        return;
+    }
     // Build full model ID: provider_id/model_id
     const fullModelId = `${context.providerId}/${selectedModelId}`;
     try {

package/dist/commands/paginated-select.js

@@ -0,0 +1,57 @@
+/**
+ * Reusable paginated select menu helpers for Discord StringSelectMenuBuilder.
+ * Discord caps select menus at 25 options. This module slices a full options
+ * list into pages of PAGE_SIZE real items and appends "← Previous page" /
+ * "Next page →" sentinel options so the user can navigate. Handlers detect
+ * sentinel values via parsePaginationValue() and re-render the same select
+ * with the new page — reusing the same customId, no new interaction handlers.
+ */
+const NAV_PREFIX = '__page_nav:';
+/** 23 real items per page, leaving room for up to 2 nav sentinels (prev + next). */
+const PAGE_SIZE = 23;
+/**
+ * Build the options array for a single page, with prev/next nav sentinels.
+ * If allOptions fits in 25 items, returns them all with no nav items.
+ */
+export function buildPaginatedOptions({ allOptions, page, }) {
+    // No pagination needed — everything fits in one Discord select
+    if (allOptions.length <= 25) {
+        return { options: allOptions, totalPages: 1 };
+    }
+    const totalPages = Math.ceil(allOptions.length / PAGE_SIZE);
+    const safePage = Math.max(0, Math.min(page, totalPages - 1));
+    const start = safePage * PAGE_SIZE;
+    const slice = allOptions.slice(start, start + PAGE_SIZE);
+    const result = [];
+    if (safePage > 0) {
+        result.push({
+            label: `← Previous page (${safePage}/${totalPages})`,
+            value: `${NAV_PREFIX}${safePage - 1}`,
+            description: 'Go to previous page',
+        });
+    }
+    result.push(...slice);
+    if (safePage < totalPages - 1) {
+        result.push({
+            label: `Next page → (${safePage + 2}/${totalPages})`,
+            value: `${NAV_PREFIX}${safePage + 1}`,
+            description: 'Go to next page',
+        });
+    }
+    return { options: result, totalPages };
+}
+/**
+ * Check if a selected value is a pagination nav sentinel.
+ * Returns the target page number if so, undefined otherwise.
+ */
+export function parsePaginationValue(value) {
+    if (!value.startsWith(NAV_PREFIX)) {
+        return undefined;
+    }
+    const pageStr = value.slice(NAV_PREFIX.length);
+    const page = Number(pageStr);
+    if (Number.isNaN(page)) {
+        return undefined;
+    }
+    return page;
+}

package/dist/commands/resume.js

@@ -3,7 +3,7 @@ import { ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
 import fs from 'node:fs';
 import { getChannelDirectory, setThreadSession, setPartMessagesBatch, getAllThreadSessionIds, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
-import { sendThreadMessage, resolveProjectDirectoryFromAutocomplete } from '../discord-utils.js';
+import { sendThreadMessage, resolveProjectDirectoryFromAutocomplete, NOTIFY_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { collectLastAssistantParts } from '../message-formatting.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
@@ -90,7 +90,7 @@ export async function handleResumeCommand({ command, }) {
         }
         catch (sendError) {
             logger.error('[RESUME] Error sending messages to thread:', sendError);
-            await sendThreadMessage(thread, `Failed to load message history, but session is connected. You can still send new messages.`);
+            await sendThreadMessage(thread, `Failed to load message history, but session is connected. You can still send new messages.`, { flags: NOTIFY_MESSAGE_FLAGS });
         }
     }
     catch (error) {

package/dist/commands/tasks.js

@@ -0,0 +1,205 @@
+// /tasks command — list all scheduled tasks sorted by next run time.
+// Renders a markdown table that the CV2 pipeline auto-formats for Discord,
+// including HTML-backed action buttons for cancellable tasks.
+import { ButtonInteraction, ChatInputCommandInteraction, ComponentType, MessageFlags, } from 'discord.js';
+import { cancelScheduledTask, listScheduledTasks, } from '../database.js';
+import { splitTablesFromMarkdown } from '../format-tables.js';
+import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
+import { formatTimeAgo } from './worktrees.js';
+function formatTimeUntil(date) {
+    const diffMs = date.getTime() - Date.now();
+    if (diffMs <= 0) {
+        return 'due now';
+    }
+    const totalSeconds = Math.floor(diffMs / 1000);
+    if (totalSeconds < 60) {
+        return `in ${totalSeconds}s`;
+    }
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    if (totalMinutes < 60) {
+        return `in ${totalMinutes}m`;
+    }
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    if (hours < 24) {
+        return minutes > 0 ? `in ${hours}h ${minutes}m` : `in ${hours}h`;
+    }
+    const days = Math.floor(hours / 24);
+    const remainingHours = hours % 24;
+    return remainingHours > 0 ? `in ${days}d ${remainingHours}h` : `in ${days}d`;
+}
+function scheduleLabel(task) {
+    if (task.schedule_kind === 'cron') {
+        return task.cron_expr || 'cron';
+    }
+    return 'one-time';
+}
+function canCancelTask(task) {
+    return task.status === 'planned' || task.status === 'running';
+}
+// Escape pipe chars and collapse whitespace so free-text fields don't break
+// GFM table column alignment.
+function sanitizeTableCell(value) {
+    return value.replaceAll('|', '\\|').replace(/\s+/g, ' ').trim();
+}
+function buildCancelButtonHtml({ buttonId }) {
+    return `<button id="${buttonId}" variant="secondary">Delete</button>`;
+}
+function buildActionCell(task) {
+    if (!canCancelTask(task)) {
+        return '-';
+    }
+    return buildCancelButtonHtml({ buttonId: `cancel-task-${task.id}` });
+}
+// Cap rows to avoid exceeding Discord's 40-component CV2 limit.
+// Each cancellable row renders as text + action row + button (~4 components),
+// so 10 rows is a safe ceiling.
+const MAX_TASK_ROWS = 10;
+function buildTaskTable({ tasks, }) {
+    const header = '| ID | Status | Prompt | Schedule | Next Run | Action |';
+    const separator = '|---|---|---|---|---|---|';
+    const rows = tasks.map((task) => {
+        const id = String(task.id);
+        const status = task.status;
+        const prompt = sanitizeTableCell(task.prompt_preview.length > 240
+            ? task.prompt_preview.slice(0, 237) + '...'
+            : task.prompt_preview);
+        const schedule = sanitizeTableCell(scheduleLabel(task));
+        const nextRun = (() => {
+            if (task.status === 'completed' ||
+                task.status === 'cancelled' ||
+                task.status === 'failed') {
+                return task.last_run_at ? formatTimeAgo(task.last_run_at) : '-';
+            }
+            return formatTimeUntil(task.next_run_at);
+        })();
+        const action = buildActionCell(task);
+        return `| ${id} | ${status} | ${prompt} | ${schedule} | ${nextRun} | ${action} |`;
+    });
+    return [header, separator, ...rows].join('\n');
+}
+function getTasksActionOwnerKey({ userId, channelId, }) {
+    return `tasks:${userId}:${channelId}`;
+}
+async function renderTasksReply({ guildId, userId, channelId, showAll, notice, editReply, }) {
+    const ownerKey = getTasksActionOwnerKey({ userId, channelId });
+    cancelHtmlActionsForOwner(ownerKey);
+    const statuses = showAll
+        ? undefined
+        : ['planned', 'running'];
+    const allTasks = await listScheduledTasks({ statuses });
+    if (allTasks.length === 0) {
+        const message = notice
+            ? `${notice}\n\nNo scheduled tasks found.`
+            : 'No scheduled tasks found.';
+        const textDisplay = {
+            type: ComponentType.TextDisplay,
+            content: message,
+        };
+        await editReply({
+            components: [textDisplay],
+            flags: MessageFlags.IsComponentsV2,
+        });
+        return;
+    }
+    const tasks = allTasks.slice(0, MAX_TASK_ROWS);
+    const truncatedNotice = allTasks.length > MAX_TASK_ROWS
+        ? `Showing ${MAX_TASK_ROWS}/${allTasks.length} tasks. Use \`kimaki task list\` for full list.`
+        : undefined;
+    const combinedNotice = [notice, truncatedNotice].filter(Boolean).join('\n');
+    const cancellableTasksByButtonId = new Map();
+    tasks.forEach((task) => {
+        if (!canCancelTask(task)) {
+            return;
+        }
+        cancellableTasksByButtonId.set(`cancel-task-${task.id}`, task);
+    });
+    const tableMarkdown = buildTaskTable({ tasks });
+    const markdown = combinedNotice
+        ? `${combinedNotice}\n\n${tableMarkdown}`
+        : tableMarkdown;
+    const segments = splitTablesFromMarkdown(markdown, {
+        resolveButtonCustomId: ({ button }) => {
+            const task = cancellableTasksByButtonId.get(button.id);
+            if (!task) {
+                return new Error(`No task registered for button ${button.id}`);
+            }
+            const actionId = registerHtmlAction({
+                ownerKey,
+                threadId: String(task.id),
+                run: async ({ interaction }) => {
+                    await handleCancelTaskAction({
+                        interaction,
+                        taskId: task.id,
+                        showAll,
+                    });
+                },
+            });
+            return buildHtmlActionCustomId(actionId);
+        },
+    });
+    const components = segments.flatMap((segment) => {
+        if (segment.type === 'components') {
+            return segment.components;
+        }
+        const textDisplay = {
+            type: ComponentType.TextDisplay,
+            content: segment.text,
+        };
+        return [textDisplay];
+    });
+    await editReply({
+        components,
+        flags: MessageFlags.IsComponentsV2,
+    });
+}
+async function handleCancelTaskAction({ interaction, taskId, showAll, }) {
+    const guildId = interaction.guildId;
+    if (!guildId) {
+        await interaction.editReply({
+            components: [
+                {
+                    type: ComponentType.TextDisplay,
+                    content: 'This action can only be used in a server.',
+                },
+            ],
+            flags: MessageFlags.IsComponentsV2,
+        });
+        return;
+    }
+    const cancelled = await cancelScheduledTask(taskId);
+    const notice = cancelled
+        ? `Cancelled task #${taskId}.`
+        : `Task #${taskId} not found or already finalized.`;
+    await renderTasksReply({
+        guildId,
+        userId: interaction.user.id,
+        channelId: interaction.channelId,
+        showAll,
+        notice,
+        editReply: (options) => {
+            return interaction.editReply(options);
+        },
+    });
+}
+export async function handleTasksCommand({ command, }) {
+    const guildId = command.guildId;
+    if (!guildId) {
+        await command.reply({
+            content: 'This command can only be used in a server.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const showAll = command.options.getBoolean('all') ?? false;
+    await command.deferReply({ flags: MessageFlags.Ephemeral });
+    await renderTasksReply({
+        guildId,
+        userId: command.user.id,
+        channelId: command.channelId,
+        showAll,
+        editReply: (options) => {
+            return command.editReply(options);
+        },
+    });
+}

package/dist/commands/undo-redo.js

@@ -52,25 +52,49 @@ export async function handleUndoCommand({ command, }) {
         return;
     }
     try {
-        // Fetch messages to find the last assistant message
-        const messagesResponse = await getClient().session.messages({
+        const client = getClient();
+        // Fetch session to check existing revert state
+        const sessionResponse = await client.session.get({
             sessionID: sessionId,
         });
+        if (sessionResponse.error) {
+            await command.editReply(`Failed to undo: ${JSON.stringify(sessionResponse.error)}`);
+            return;
+        }
+        const messagesResponse = await client.session.messages({
+            sessionID: sessionId,
+        });
+        if (messagesResponse.error) {
+            await command.editReply(`Failed to undo: ${JSON.stringify(messagesResponse.error)}`);
+            return;
+        }
         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');
+        // Follow the same approach as the OpenCode TUI (use-session-commands.tsx):
+        // find the last user message that is before the current revert point
+        // (or the last user message if no revert is active). This matches the
+        // TUI's `findLast(userMessages(), (x) => !revert || x.id < revert)`.
+        const currentRevert = sessionResponse.data?.revert?.messageID;
+        const userMessages = messagesResponse.data.filter((m) => {
+            return m.info.role === 'user';
+        });
+        const targetUserMessage = [...userMessages].reverse().find((m) => {
+            return !currentRevert || m.info.id < currentRevert;
+        });
+        if (!targetUserMessage) {
+            await command.editReply('No messages to undo');
             return;
         }
-        const response = await getClient().session.revert({
+        // session.revert() reverts filesystem patches (file edits, writes) and
+        // marks the session with revert.messageID. Messages are NOT deleted — they
+        // get cleaned up automatically on the next promptAsync() call via
+        // SessionRevert.cleanup(). The model only sees messages before the revert
+        // point when processing the next prompt.
+        const response = await client.session.revert({
             sessionID: sessionId,
-            messageID: lastAssistantMessage.info.id,
+            messageID: targetUserMessage.info.id,
         });
         if (response.error) {
             await command.editReply(`Failed to undo: ${JSON.stringify(response.error)}`);
@@ -79,8 +103,8 @@ export async function handleUndoCommand({ command, }) {
         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}`);
+        await command.editReply(`Undone - reverted last assistant message${diffInfo}`);
+        logger.log(`Session ${sessionId} reverted to before user message ${targetUserMessage.info.id}`);
     }
     catch (error) {
         logger.error('[UNDO] Error:', error);
@@ -134,23 +158,61 @@ export async function handleRedoCommand({ command, }) {
         return;
     }
     try {
-        // Check if session has reverted state
-        const sessionResponse = await getClient().session.get({
+        const client = getClient();
+        // Fetch session to check existing revert state
+        const sessionResponse = await client.session.get({
             sessionID: sessionId,
         });
-        if (!sessionResponse.data?.revert) {
+        if (sessionResponse.error) {
+            await command.editReply(`Failed to redo: ${JSON.stringify(sessionResponse.error)}`);
+            return;
+        }
+        const revertMessageID = sessionResponse.data?.revert?.messageID;
+        if (!revertMessageID) {
             await command.editReply('Nothing to redo - no previous undo found');
             return;
         }
-        const response = await getClient().session.unrevert({
+        // Follow the same approach as the OpenCode TUI (use-session-commands.tsx):
+        // find the next user message after the current revert point. If one exists,
+        // move the revert cursor forward to it (one step redo). If none exists,
+        // fully unrevert — we're at the end of the message history.
+        const messagesResponse = await client.session.messages({
+            sessionID: sessionId,
+        });
+        if (messagesResponse.error) {
+            await command.editReply(`Failed to redo: ${JSON.stringify(messagesResponse.error)}`);
+            return;
+        }
+        const userMessages = (messagesResponse.data ?? []).filter((m) => {
+            return m.info.role === 'user';
+        });
+        const nextMessage = userMessages.find((m) => {
+            return m.info.id > revertMessageID;
+        });
+        if (!nextMessage) {
+            // No more messages after revert point — fully unrevert
+            const response = await client.session.unrevert({
+                sessionID: sessionId,
+            });
+            if (response.error) {
+                await command.editReply(`Failed to redo: ${JSON.stringify(response.error)}`);
+                return;
+            }
+            await command.editReply('Restored - session fully back to previous state');
+            logger.log(`Session ${sessionId} unrevert completed`);
+            return;
+        }
+        // Move revert cursor forward one step to the next user message
+        const response = await client.session.revert({
             sessionID: sessionId,
+            messageID: nextMessage.info.id,
         });
         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`);
+        await command.editReply('Restored one step forward');
+        logger.log(`Session ${sessionId} redo: moved revert to ${nextMessage.info.id}`);
     }
     catch (error) {
         logger.error('[REDO] Error:', error);