kimaki 0.4.38 → 0.4.40

package/src/commands/fork.ts

@@ -14,6 +14,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from '../discord-utils.js'
 import { collectLastAssistantParts } from '../message-formatting.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const sessionLogger = createLogger('SESSION')
 const forkLogger = createLogger('FORK')
@@ -71,9 +72,15 @@ export async function handleForkCommand(interaction: ChatInputCommandInteraction
 
   const sessionId = row.session_id
 
-  try {
-    const getClient = await initializeOpencodeForDirectory(directory)
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (getClient instanceof Error) {
+    await interaction.editReply({
+      content: `Failed to load messages: ${getClient.message}`,
+    })
+    return
+  }
 
+  try {
     const messagesResponse = await getClient().session.messages({
       path: { id: sessionId },
     })
@@ -85,7 +92,7 @@ export async function handleForkCommand(interaction: ChatInputCommandInteraction
       return
     }
 
-    const userMessages = messagesResponse.data.filter((m) => m.info.role === 'user')
+    const userMessages = messagesResponse.data.filter((m: { info: { role: string } }) => m.info.role === 'user')
 
     if (userMessages.length === 0) {
       await interaction.editReply({
@@ -96,8 +103,8 @@ export async function handleForkCommand(interaction: ChatInputCommandInteraction
 
     const recentMessages = userMessages.slice(-25)
 
-    const options = recentMessages.map((m, index) => {
-      const textPart = m.parts.find((p) => p.type === 'text') as
+    const options = recentMessages.map((m: { parts: Array<{ type: string; text?: string }>; info: { id: string; time: { created: number } } }, index: number) => {
+      const textPart = m.parts.find((p: { type: string }) => p.type === 'text') as
         | { type: 'text'; text: string }
         | undefined
       const preview = textPart?.text?.slice(0, 80) || '(no text)'
@@ -163,9 +170,13 @@ export async function handleForkSelectMenu(
 
   await interaction.deferReply({ ephemeral: false })
 
-  try {
-    const getClient = await initializeOpencodeForDirectory(directory)
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (getClient instanceof Error) {
+    await interaction.editReply(`Failed to fork session: ${getClient.message}`)
+    return
+  }
 
+  try {
     const forkResponse = await getClient().session.fork({
       path: { id: sessionId },
       body: { messageID: selectedMessageId },

package/src/commands/model.ts

@@ -15,6 +15,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
 import { abortAndRetrySession } from '../session-handler.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const modelLogger = createLogger('MODEL')
 
@@ -128,6 +129,10 @@ export async function handleModelCommand({
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await interaction.editReply({ content: getClient.message })
+      return
+    }
 
     const providersResponse = await getClient().provider.list({
       query: { directory: projectDirectory },
@@ -232,6 +237,13 @@ export async function handleProviderSelectMenu(
 
   try {
     const getClient = await initializeOpencodeForDirectory(context.dir)
+    if (getClient instanceof Error) {
+      await interaction.editReply({
+        content: getClient.message,
+        components: [],
+      })
+      return
+    }
 
     const providersResponse = await getClient().provider.list({
       query: { directory: context.dir },

package/src/commands/remove-project.ts

@@ -1,6 +1,7 @@
 // /remove-project command - Remove Discord channels for a project.
 
 import path from 'node:path'
+import * as errore from 'errore'
 import type { CommandContext, AutocompleteContext } from './types.js'
 import { getDatabase } from '../database.js'
 import { createLogger } from '../logger.js'
@@ -36,19 +37,27 @@ export async function handleRemoveProjectCommand({ command, appId }: CommandCont
     const failedChannels: string[] = []
 
     for (const { channel_id, channel_type } of channels) {
-      try {
-        const channel = await guild.channels.fetch(channel_id).catch(() => null)
-
-        if (channel) {
+      const channel = await errore.tryAsync({
+        try: () => guild.channels.fetch(channel_id),
+        catch: (e) => e as Error,
+      })
+      
+      if (channel instanceof Error) {
+        logger.error(`Failed to fetch channel ${channel_id}:`, channel)
+        failedChannels.push(`${channel_type}: ${channel_id}`)
+        continue
+      }
+      
+      if (channel) {
+        try {
           await channel.delete(`Removed by /remove-project command`)
           deletedChannels.push(`${channel_type}: ${channel_id}`)
-        } else {
-          // Channel doesn't exist in this guild or was already deleted
-          deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`)
+        } catch (error) {
+          logger.error(`Failed to delete channel ${channel_id}:`, error)
+          failedChannels.push(`${channel_type}: ${channel_id}`)
         }
-      } catch (error) {
-        logger.error(`Failed to delete channel ${channel_id}:`, error)
-        failedChannels.push(`${channel_type}: ${channel_id}`)
+      } else {
+        deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`)
       }
     }
 
@@ -103,13 +112,16 @@ export async function handleRemoveProjectAutocomplete({
     const projectsInGuild: { directory: string; channelId: string }[] = []
 
     for (const { directory, channel_id } of allChannels) {
-      try {
-        const channel = await guild.channels.fetch(channel_id).catch(() => null)
-        if (channel) {
-          projectsInGuild.push({ directory, channelId: channel_id })
-        }
-      } catch {
+      const channel = await errore.tryAsync({
+        try: () => guild.channels.fetch(channel_id),
+        catch: (e) => e as Error,
+      })
+      if (channel instanceof Error) {
         // Channel not in this guild, skip
+        continue
+      }
+      if (channel) {
+        projectsInGuild.push({ directory, channelId: channel_id })
       }
     }
 

package/src/commands/resume.ts

@@ -14,6 +14,7 @@ import { sendThreadMessage, resolveTextChannel, getKimakiMetadata } from '../dis
 import { extractTagsArrays } from '../xml.js'
 import { collectLastAssistantParts } from '../message-formatting.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const logger = createLogger('RESUME')
 
@@ -60,6 +61,10 @@ export async function handleResumeCommand({ command, appId }: CommandContext): P
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await command.editReply(getClient.message)
+      return
+    }
 
     const sessionResponse = await getClient().session.get({
       path: { id: sessionId },
@@ -168,6 +173,10 @@ export async function handleResumeAutocomplete({
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await interaction.respond([])
+      return
+    }
 
     const sessionsResponse = await getClient().session.list()
     if (!sessionsResponse.data) {

package/src/commands/session.ts

@@ -1,4 +1,4 @@
-// /session command - Start a new OpenCode session.
+// /new-session command - Start a new OpenCode session.
 
 import { ChannelType, type TextChannel } from 'discord.js'
 import fs from 'node:fs'
@@ -10,6 +10,7 @@ import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { extractTagsArrays } from '../xml.js'
 import { handleOpencodeSession } from '../session-handler.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const logger = createLogger('SESSION')
 
@@ -58,6 +59,10 @@ export async function handleSessionCommand({ command, appId }: CommandContext):
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await command.editReply(getClient.message)
+      return
+    }
 
     const files = filesString
       .split(',')
@@ -128,6 +133,10 @@ async function handleAgentAutocomplete({ interaction, appId }: AutocompleteConte
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await interaction.respond([])
+      return
+    }
 
     const agentsResponse = await getClient().app.agents({
       query: { directory: projectDirectory },
@@ -207,6 +216,10 @@ export async function handleSessionAutocomplete({
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await interaction.respond([])
+      return
+    }
 
     const response = await getClient().find.files({
       query: {

package/src/commands/share.ts

@@ -6,6 +6,7 @@ import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const logger = createLogger('SHARE')
 
@@ -63,8 +64,17 @@ export async function handleShareCommand({ command }: CommandContext): Promise<v
 
   const sessionId = row.session_id
 
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (getClient instanceof Error) {
+    await command.reply({
+      content: `Failed to share session: ${getClient.message}`,
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
   try {
-    const getClient = await initializeOpencodeForDirectory(directory)
     const response = await getClient().session.share({
       path: { id: sessionId },
     })

package/src/commands/undo-redo.ts

@@ -6,6 +6,7 @@ import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const logger = createLogger('UNDO-REDO')
 
@@ -63,11 +64,15 @@ export async function handleUndoCommand({ command }: CommandContext): Promise<vo
 
   const sessionId = row.session_id
 
-  try {
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
 
-    const getClient = await initializeOpencodeForDirectory(directory)
+  const getClient = await initializeOpencodeForDirectory(directory)
+  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({
       path: { id: sessionId },
@@ -166,11 +171,15 @@ export async function handleRedoCommand({ command }: CommandContext): Promise<vo
 
   const sessionId = row.session_id
 
-  try {
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
 
-    const getClient = await initializeOpencodeForDirectory(directory)
+  const getClient = await initializeOpencodeForDirectory(directory)
+  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({
       path: { id: sessionId },

package/src/commands/worktree.ts

@@ -0,0 +1,243 @@
+// Worktree management command: /new-worktree
+// Uses OpenCode SDK v2 to create worktrees with kimaki- prefix
+// Creates thread immediately, then worktree in background so user can type
+
+import { ChannelType, type TextChannel, type ThreadChannel, type Message } from 'discord.js'
+import fs from 'node:fs'
+import type { CommandContext } from './types.js'
+import {
+  createPendingWorktree,
+  setWorktreeReady,
+  setWorktreeError,
+} from '../database.js'
+import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode.js'
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { extractTagsArrays } from '../xml.js'
+import { createLogger } from '../logger.js'
+import * as errore from 'errore'
+
+const logger = createLogger('WORKTREE')
+
+class WorktreeError extends Error {
+  constructor(message: string, options?: { cause?: unknown }) {
+    super(message, options)
+    this.name = 'WorktreeError'
+  }
+}
+
+/**
+ * Format worktree name: lowercase, spaces to dashes, remove special chars, add kimaki- prefix.
+ * "My Feature" → "kimaki-my-feature"
+ */
+function formatWorktreeName(name: string): string {
+  const formatted = name
+    .toLowerCase()
+    .trim()
+    .replace(/\s+/g, '-')
+    .replace(/[^a-z0-9-]/g, '')
+
+  return `kimaki-${formatted}`
+}
+
+/**
+ * Get project directory from channel topic.
+ */
+function getProjectDirectoryFromChannel(
+  channel: TextChannel,
+  appId: string,
+): string | WorktreeError {
+  if (!channel.topic) {
+    return new WorktreeError('This channel has no topic configured')
+  }
+
+  const extracted = extractTagsArrays({
+    xml: channel.topic,
+    tags: ['kimaki.directory', 'kimaki.app'],
+  })
+
+  const projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
+  const channelAppId = extracted['kimaki.app']?.[0]?.trim()
+
+  if (channelAppId && channelAppId !== appId) {
+    return new WorktreeError('This channel is not configured for this bot')
+  }
+
+  if (!projectDirectory) {
+    return new WorktreeError('This channel is not configured with a project directory')
+  }
+
+  if (!fs.existsSync(projectDirectory)) {
+    return new WorktreeError(`Directory does not exist: ${projectDirectory}`)
+  }
+
+  return projectDirectory
+}
+
+/**
+ * Create worktree in background and update starter message when done.
+ */
+async function createWorktreeInBackground({
+  thread,
+  starterMessage,
+  worktreeName,
+  projectDirectory,
+  clientV2,
+}: {
+  thread: ThreadChannel
+  starterMessage: Message
+  worktreeName: string
+  projectDirectory: string
+  clientV2: ReturnType<typeof getOpencodeClientV2> & {}
+}): Promise<void> {
+  // Create worktree using SDK v2
+  logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}`)
+  const worktreeResult = await errore.tryAsync({
+    try: async () => {
+      const response = await clientV2.worktree.create({
+        directory: projectDirectory,
+        worktreeCreateInput: {
+          name: worktreeName,
+        },
+      })
+
+      if (response.error) {
+        throw new Error(`SDK error: ${JSON.stringify(response.error)}`)
+      }
+
+      if (!response.data) {
+        throw new Error('No worktree data returned from SDK')
+      }
+
+      return response.data
+    },
+    catch: (e) => new WorktreeError('Failed to create worktree', { cause: e }),
+  })
+
+  if (errore.isError(worktreeResult)) {
+    const errorMsg = worktreeResult.message
+    logger.error('[NEW-WORKTREE] Error:', worktreeResult.cause)
+    setWorktreeError({ threadId: thread.id, errorMessage: errorMsg })
+    await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`)
+    return
+  }
+
+  // Success - update database and edit starter message
+  setWorktreeReady({ threadId: thread.id, worktreeDirectory: worktreeResult.directory })
+  await starterMessage.edit(
+    `🌳 **Worktree: ${worktreeName}**\n` +
+    `📁 \`${worktreeResult.directory}\`\n` +
+    `🌿 Branch: \`${worktreeResult.branch}\``
+  )
+}
+
+export async function handleNewWorktreeCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  await command.deferReply({ ephemeral: false })
+
+  const rawName = command.options.getString('name', true)
+  const worktreeName = formatWorktreeName(rawName)
+
+  if (worktreeName === 'kimaki-') {
+    await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.')
+    return
+  }
+
+  const channel = command.channel
+
+  if (!channel || channel.type !== ChannelType.GuildText) {
+    await command.editReply('This command can only be used in text channels')
+    return
+  }
+
+  const textChannel = channel as TextChannel
+
+  const projectDirectory = getProjectDirectoryFromChannel(textChannel, appId)
+  if (errore.isError(projectDirectory)) {
+    await command.editReply(projectDirectory.message)
+    return
+  }
+
+  // Initialize opencode and check if worktree already exists
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (errore.isError(getClient)) {
+    await command.editReply(`Failed to initialize OpenCode: ${getClient.message}`)
+    return
+  }
+
+  const clientV2 = getOpencodeClientV2(projectDirectory)
+  if (!clientV2) {
+    await command.editReply('Failed to get OpenCode client')
+    return
+  }
+
+  // Check if worktree with this name already exists
+  // SDK returns array of directory paths like "~/.opencode/worktree/abc/kimaki-my-feature"
+  const listResult = await errore.tryAsync({
+    try: async () => {
+      const response = await clientV2.worktree.list({ directory: projectDirectory })
+      return response.data || []
+    },
+    catch: (e) => new WorktreeError('Failed to list worktrees', { cause: e }),
+  })
+
+  if (errore.isError(listResult)) {
+    await command.editReply(listResult.message)
+    return
+  }
+
+  // Check if any worktree path ends with our name
+  const existingWorktree = listResult.find((dir) => dir.endsWith(`/${worktreeName}`))
+  if (existingWorktree) {
+    await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktree}\``)
+    return
+  }
+
+  // Create thread immediately so user can start typing
+  const result = await errore.tryAsync({
+    try: async () => {
+      const starterMessage = await textChannel.send({
+        content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+        flags: SILENT_MESSAGE_FLAGS,
+      })
+
+      const thread = await starterMessage.startThread({
+        name: `worktree: ${worktreeName}`,
+        autoArchiveDuration: 1440,
+        reason: 'Worktree session',
+      })
+
+      return { thread, starterMessage }
+    },
+    catch: (e) => new WorktreeError('Failed to create thread', { cause: e }),
+  })
+
+  if (errore.isError(result)) {
+    logger.error('[NEW-WORKTREE] Error:', result.cause)
+    await command.editReply(result.message)
+    return
+  }
+
+  const { thread, starterMessage } = result
+
+  // Store pending worktree in database
+  createPendingWorktree({
+    threadId: thread.id,
+    worktreeName,
+    projectDirectory,
+  })
+
+  await command.editReply(`Creating worktree in ${thread.toString()}`)
+
+  // Create worktree in background (don't await)
+  createWorktreeInBackground({
+    thread,
+    starterMessage,
+    worktreeName,
+    projectDirectory,
+    clientV2,
+  }).catch((e) => {
+    logger.error('[NEW-WORKTREE] Background error:', e)
+  })
+}

package/src/database.ts

@@ -5,6 +5,7 @@
 import Database from 'better-sqlite3'
 import fs from 'node:fs'
 import path from 'node:path'
+import * as errore from 'errore'
 import { createLogger } from './logger.js'
 import { getDataDir } from './config.js'
 
@@ -16,10 +17,14 @@ export function getDatabase(): Database.Database {
   if (!db) {
     const dataDir = getDataDir()
 
-    try {
-      fs.mkdirSync(dataDir, { recursive: true })
-    } catch (error) {
-      dbLogger.error(`Failed to create data directory ${dataDir}:`, error)
+    const mkdirError = errore.tryFn({
+      try: () => {
+        fs.mkdirSync(dataDir, { recursive: true })
+      },
+      catch: (e) => e as Error,
+    })
+    if (mkdirError instanceof Error) {
+      dbLogger.error(`Failed to create data directory ${dataDir}:`, mkdirError.message)
     }
 
     const dbPath = path.join(dataDir, 'discord-sessions.db')
@@ -85,6 +90,20 @@ export function getDatabase(): Database.Database {
       )
     `)
 
+    // Track worktrees created for threads (for /new-worktree command)
+    // status: 'pending' while creating, 'ready' when done, 'error' if failed
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS thread_worktrees (
+        thread_id TEXT PRIMARY KEY,
+        worktree_name TEXT NOT NULL,
+        worktree_directory TEXT,
+        project_directory TEXT NOT NULL,
+        status TEXT DEFAULT 'pending',
+        error_message TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
     runModelMigrations(db)
   }
 
@@ -238,6 +257,87 @@ export function setSessionAgent(sessionId: string, agentName: string): void {
   )
 }
 
+// Worktree status types
+export type WorktreeStatus = 'pending' | 'ready' | 'error'
+
+export type ThreadWorktree = {
+  thread_id: string
+  worktree_name: string
+  worktree_directory: string | null
+  project_directory: string
+  status: WorktreeStatus
+  error_message: string | null
+}
+
+/**
+ * Get the worktree info for a thread.
+ */
+export function getThreadWorktree(threadId: string): ThreadWorktree | undefined {
+  const db = getDatabase()
+  return db.prepare('SELECT * FROM thread_worktrees WHERE thread_id = ?').get(threadId) as
+    | ThreadWorktree
+    | undefined
+}
+
+/**
+ * Create a pending worktree entry for a thread.
+ */
+export function createPendingWorktree({
+  threadId,
+  worktreeName,
+  projectDirectory,
+}: {
+  threadId: string
+  worktreeName: string
+  projectDirectory: string
+}): void {
+  const db = getDatabase()
+  db.prepare(
+    `INSERT OR REPLACE INTO thread_worktrees (thread_id, worktree_name, project_directory, status) VALUES (?, ?, ?, 'pending')`,
+  ).run(threadId, worktreeName, projectDirectory)
+}
+
+/**
+ * Mark a worktree as ready with its directory.
+ */
+export function setWorktreeReady({
+  threadId,
+  worktreeDirectory,
+}: {
+  threadId: string
+  worktreeDirectory: string
+}): void {
+  const db = getDatabase()
+  db.prepare(
+    `UPDATE thread_worktrees SET worktree_directory = ?, status = 'ready' WHERE thread_id = ?`,
+  ).run(worktreeDirectory, threadId)
+}
+
+/**
+ * Mark a worktree as failed with error message.
+ */
+export function setWorktreeError({
+  threadId,
+  errorMessage,
+}: {
+  threadId: string
+  errorMessage: string
+}): void {
+  const db = getDatabase()
+  db.prepare(`UPDATE thread_worktrees SET status = 'error', error_message = ? WHERE thread_id = ?`).run(
+    errorMessage,
+    threadId,
+  )
+}
+
+/**
+ * Delete the worktree info for a thread.
+ */
+export function deleteThreadWorktree(threadId: string): void {
+  const db = getDatabase()
+  db.prepare('DELETE FROM thread_worktrees WHERE thread_id = ?').run(threadId)
+}
+
 export function closeDatabase(): void {
   if (db) {
     db.close()