kimaki 0.4.78 → 0.4.80

package/src/commands/model.ts

@@ -31,6 +31,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)
 
@@ -51,6 +52,10 @@ type PendingModelContext = {
   selectedModelId?: string
   selectedVariant?: string | null
   availableVariants?: string[]
+  providerPage?: number
+  modelPage?: number
+  /** Header text shown above the provider select (current model info). */
+  providerSelectHeader?: string
 }
 
 const pendingModelContexts = new Map<string, PendingModelContext>()
@@ -464,6 +469,7 @@ export async function handleModelCommand({
     })()
 
     // 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,
@@ -471,13 +477,13 @@ export async function handleModelCommand({
       isThread: isThread,
       thread: isThread ? (channel as ThreadChannel) : 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 {
@@ -491,6 +497,11 @@ export async function handleModelCommand({
         }
       })
 
+    const { options } = buildPaginatedOptions({
+      allOptions: allProviderOptions,
+      page: 0,
+    })
+
     const selectMenu = new StringSelectMenuBuilder()
       .setCustomId(`model_provider:${contextHash}`)
       .setPlaceholder('Select a provider')
@@ -500,7 +511,7 @@ export async function handleModelCommand({
       new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
 
     await interaction.editReply({
-      content: `**Set Model Preference**\n${currentModelText}${variantText}\nSelect a provider:`,
+      content: providerSelectHeader,
       components: [actionRow],
     })
   } catch (error) {
@@ -547,6 +558,47 @@ export async function handleProviderSelectMenu(
     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<StringSelectMenuBuilder>().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) {
@@ -597,15 +649,13 @@ export async function handleProviderSelectMenu(
       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'
@@ -616,6 +666,11 @@ export async function handleProviderSelectMenu(
       }
     })
 
+    const { options } = buildPaginatedOptions({
+      allOptions: allModelOptions,
+      page: 0,
+    })
+
     const selectMenu = new StringSelectMenuBuilder()
       .setCustomId(`model_select:${contextHash}`)
       .setPlaceholder('Select a model')
@@ -673,6 +728,46 @@ export async function handleModelSelectMenu(
     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<StringSelectMenuBuilder>().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}`
 

package/src/commands/paginated-select.ts

@@ -0,0 +1,81 @@
+/**
+ * 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
+
+export type SelectOption = {
+  label: string
+  value: string
+  description?: string
+}
+
+/**
+ * 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,
+}: {
+  allOptions: SelectOption[]
+  page: number
+}): { options: SelectOption[]; totalPages: number } {
+  // 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: SelectOption[] = []
+
+  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: string,
+): number | undefined {
+  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/src/commands/resume.ts

@@ -15,7 +15,11 @@ import {
   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'
@@ -153,6 +157,7 @@ export async function handleResumeCommand({
       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/src/commands/tasks.ts

@@ -0,0 +1,293 @@
+// /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,
+  type APIMessageTopLevelComponent,
+  type APITextDisplayComponent,
+  type InteractionEditReplyOptions,
+} from 'discord.js'
+import {
+  cancelScheduledTask,
+  listScheduledTasks,
+  type ScheduledTask,
+  type ScheduledTaskStatus,
+} 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: Date): string {
+  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: ScheduledTask): string {
+  if (task.schedule_kind === 'cron') {
+    return task.cron_expr || 'cron'
+  }
+  return 'one-time'
+}
+
+function canCancelTask(task: ScheduledTask): boolean {
+  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: string): string {
+  return value.replaceAll('|', '\\|').replace(/\s+/g, ' ').trim()
+}
+
+function buildCancelButtonHtml({ buttonId }: { buttonId: string }): string {
+  return `<button id="${buttonId}" variant="secondary">Delete</button>`
+}
+
+function buildActionCell(task: ScheduledTask): string {
+  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,
+}: {
+  tasks: ScheduledTask[]
+}): string {
+  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,
+}: {
+  userId: string
+  channelId: string
+}): string {
+  return `tasks:${userId}:${channelId}`
+}
+
+type TasksReplyTarget = {
+  guildId: string
+  userId: string
+  channelId: string
+  showAll: boolean
+  notice?: string
+  editReply: (
+    options: string | InteractionEditReplyOptions,
+  ) => Promise<unknown>
+}
+
+async function renderTasksReply({
+  guildId,
+  userId,
+  channelId,
+  showAll,
+  notice,
+  editReply,
+}: TasksReplyTarget): Promise<void> {
+  const ownerKey = getTasksActionOwnerKey({ userId, channelId })
+  cancelHtmlActionsForOwner(ownerKey)
+
+  const statuses: ScheduledTaskStatus[] | undefined = 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: APITextDisplayComponent = {
+      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<string, ScheduledTask>()
+  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: APIMessageTopLevelComponent[] = segments.flatMap(
+    (segment) => {
+      if (segment.type === 'components') {
+        return segment.components
+      }
+      const textDisplay: APITextDisplayComponent = {
+        type: ComponentType.TextDisplay,
+        content: segment.text,
+      }
+      return [textDisplay]
+    },
+  )
+
+  await editReply({
+    components,
+    flags: MessageFlags.IsComponentsV2,
+  })
+}
+
+async function handleCancelTaskAction({
+  interaction,
+  taskId,
+  showAll,
+}: {
+  interaction: ButtonInteraction
+  taskId: number
+  showAll: boolean
+}): Promise<void> {
+  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,
+}: {
+  command: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  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)
+    },
+  })
+}