kimaki 0.4.43 → 0.4.45

package/src/commands/worktree.ts

@@ -9,11 +9,14 @@ import {
   createPendingWorktree,
   setWorktreeReady,
   setWorktreeError,
+  getChannelDirectory,
+  getThreadWorktree,
 } 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 { createWorktreeWithSubmodules } from '../worktree-utils.js'
+import { WORKTREE_PREFIX } from './merge-worktree.js'
 import * as errore from 'errore'
 
 const logger = createLogger('WORKTREE')
@@ -26,51 +29,64 @@ class WorktreeError extends Error {
 }
 
 /**
- * Format worktree name: lowercase, spaces to dashes, remove special chars, add kimaki- prefix.
- * "My Feature" → "kimaki-my-feature"
+ * Format worktree name: lowercase, spaces to dashes, remove special chars, add opencode/kimaki- prefix.
+ * "My Feature" → "opencode/kimaki-my-feature"
+ * Returns empty string if no valid name can be extracted.
  */
-function formatWorktreeName(name: string): string {
+export function formatWorktreeName(name: string): string {
   const formatted = name
     .toLowerCase()
     .trim()
     .replace(/\s+/g, '-')
     .replace(/[^a-z0-9-]/g, '')
 
-  return `kimaki-${formatted}`
+  if (!formatted) {
+    return ''
+  }
+  return `opencode/kimaki-${formatted}`
 }
 
 /**
- * Get project directory from channel topic.
+ * Derive worktree name from thread name.
+ * Handles existing "⬦ worktree: opencode/kimaki-name" format or uses thread name directly.
+ */
+function deriveWorktreeNameFromThread(threadName: string): string {
+  // Handle existing "⬦ worktree: opencode/kimaki-name" format
+  const worktreeMatch = threadName.match(/worktree:\s*(.+)$/i)
+  const extractedName = worktreeMatch?.[1]?.trim()
+  if (extractedName) {
+    // If already has opencode/kimaki- prefix, return as is
+    if (extractedName.startsWith('opencode/kimaki-')) {
+      return extractedName
+    }
+    return formatWorktreeName(extractedName)
+  }
+  // Use thread name directly
+  return formatWorktreeName(threadName)
+}
+
+/**
+ * Get project directory from database.
  */
 function getProjectDirectoryFromChannel(
   channel: TextChannel,
   appId: string,
 ): string | WorktreeError {
-  if (!channel.topic) {
-    return new WorktreeError('This channel has no topic configured')
-  }
+  const channelConfig = getChannelDirectory(channel.id)
 
-  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 (!channelConfig) {
+    return new WorktreeError('This channel is not configured with a project directory')
   }
 
-  if (!projectDirectory) {
-    return new WorktreeError('This channel is not configured with a project directory')
+  if (channelConfig.appId && channelConfig.appId !== appId) {
+    return new WorktreeError('This channel is not configured for this bot')
   }
 
-  if (!fs.existsSync(projectDirectory)) {
-    return new WorktreeError(`Directory does not exist: ${projectDirectory}`)
+  if (!fs.existsSync(channelConfig.directory)) {
+    return new WorktreeError(`Directory does not exist: ${channelConfig.directory}`)
   }
 
-  return projectDirectory
+  return channelConfig.directory
 }
 
 /**
@@ -89,33 +105,17 @@ async function createWorktreeInBackground({
   projectDirectory: string
   clientV2: ReturnType<typeof getOpencodeClientV2> & {}
 }): Promise<void> {
-  // Create worktree using SDK v2
+  // Create worktree using SDK v2 and init submodules
   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 }),
+  const worktreeResult = await createWorktreeWithSubmodules({
+    clientV2,
+    directory: projectDirectory,
+    name: worktreeName,
   })
 
-  if (errore.isError(worktreeResult)) {
+  if (worktreeResult instanceof Error) {
     const errorMsg = worktreeResult.message
-    logger.error('[NEW-WORKTREE] Error:', worktreeResult.cause)
+    logger.error('[NEW-WORKTREE] Error:', worktreeResult)
     setWorktreeError({ threadId: thread.id, errorMessage: errorMsg })
     await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`)
     return
@@ -136,18 +136,38 @@ export async function handleNewWorktreeCommand({
 }: CommandContext): Promise<void> {
   await command.deferReply({ ephemeral: false })
 
-  const rawName = command.options.getString('name', true)
-  const worktreeName = formatWorktreeName(rawName)
+  const channel = command.channel
+  if (!channel) {
+    await command.editReply('Cannot determine channel')
+    return
+  }
 
-  if (worktreeName === 'kimaki-') {
-    await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.')
+  const isThread =
+    channel.type === ChannelType.PublicThread || channel.type === ChannelType.PrivateThread
+
+  // Handle command in existing thread - attach worktree to this thread
+  if (isThread) {
+    await handleWorktreeInThread({ command, appId, thread: channel as ThreadChannel })
     return
   }
 
-  const channel = command.channel
+  // Handle command in text channel - create new thread with worktree (existing behavior)
+  if (channel.type !== ChannelType.GuildText) {
+    await command.editReply('This command can only be used in text channels or threads')
+    return
+  }
 
-  if (!channel || channel.type !== ChannelType.GuildText) {
-    await command.editReply('This command can only be used in text channels')
+  const rawName = command.options.getString('name')
+  if (!rawName) {
+    await command.editReply(
+      'Name is required when creating a worktree from a text channel. Use `/new-worktree name:my-feature`',
+    )
+    return
+  }
+
+  const worktreeName = formatWorktreeName(rawName)
+  if (!worktreeName) {
+    await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.')
     return
   }
 
@@ -203,7 +223,7 @@ export async function handleNewWorktreeCommand({
       })
 
       const thread = await starterMessage.startThread({
-        name: `worktree: ${worktreeName}`,
+        name: `${WORKTREE_PREFIX}worktree: ${worktreeName}`,
         autoArchiveDuration: 1440,
         reason: 'Worktree session',
       })
@@ -241,3 +261,102 @@ export async function handleNewWorktreeCommand({
     logger.error('[NEW-WORKTREE] Background error:', e)
   })
 }
+
+/**
+ * Handle /new-worktree when called inside an existing thread.
+ * Attaches a worktree to the current thread, using thread name if no name provided.
+ */
+async function handleWorktreeInThread({
+  command,
+  appId,
+  thread,
+}: CommandContext & { thread: ThreadChannel }): Promise<void> {
+  // Error if thread already has a worktree
+  if (getThreadWorktree(thread.id)) {
+    await command.editReply('This thread already has a worktree attached.')
+    return
+  }
+
+  // Get worktree name from parameter or derive from thread name
+  const rawName = command.options.getString('name')
+  const worktreeName = rawName ? formatWorktreeName(rawName) : deriveWorktreeNameFromThread(thread.name)
+
+  if (!worktreeName) {
+    await command.editReply('Invalid worktree name. Please provide a name or rename the thread.')
+    return
+  }
+
+  // Get parent channel for project directory
+  const parent = thread.parent
+  if (!parent || parent.type !== ChannelType.GuildText) {
+    await command.editReply('Cannot determine parent channel')
+    return
+  }
+
+  const projectDirectory = getProjectDirectoryFromChannel(parent as TextChannel, appId)
+  if (errore.isError(projectDirectory)) {
+    await command.editReply(projectDirectory.message)
+    return
+  }
+
+  // Initialize opencode
+  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
+  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
+  }
+
+  const existingWorktreePath = listResult.find((dir) => dir.endsWith(`/${worktreeName}`))
+  if (existingWorktreePath) {
+    await command.editReply(
+      `Worktree \`${worktreeName}\` already exists at \`${existingWorktreePath}\``,
+    )
+    return
+  }
+
+  // Store pending worktree in database for this existing thread
+  createPendingWorktree({
+    threadId: thread.id,
+    worktreeName,
+    projectDirectory,
+  })
+
+  // Send status message in thread
+  const statusMessage = await thread.send({
+    content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+    flags: SILENT_MESSAGE_FLAGS,
+  })
+
+  await command.editReply(`Creating worktree \`${worktreeName}\` for this thread...`)
+
+  // Create worktree in background
+  createWorktreeInBackground({
+    thread,
+    starterMessage: statusMessage,
+    worktreeName,
+    projectDirectory,
+    clientV2,
+  }).catch((e) => {
+    logger.error('[NEW-WORKTREE] Background error:', e)
+  })
+}

package/src/database.ts

@@ -105,6 +105,8 @@ export function getDatabase(): Database.Database {
     `)
 
     runModelMigrations(db)
+    runWorktreeSettingsMigrations(db)
+    runVerbosityMigrations(db)
   }
 
   return db
@@ -338,6 +340,112 @@ export function deleteThreadWorktree(threadId: string): void {
   db.prepare('DELETE FROM thread_worktrees WHERE thread_id = ?').run(threadId)
 }
 
+/**
+ * Run migrations for channel worktree settings table.
+ * Called on startup. Allows per-channel opt-in for automatic worktree creation.
+ */
+export function runWorktreeSettingsMigrations(database?: Database.Database): void {
+  const targetDb = database || getDatabase()
+
+  targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_worktrees (
+      channel_id TEXT PRIMARY KEY,
+      enabled INTEGER NOT NULL DEFAULT 0,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `)
+
+  dbLogger.log('Channel worktree settings migrations complete')
+}
+
+// Verbosity levels for controlling output detail
+export type VerbosityLevel = 'tools-and-text' | 'text-only'
+
+export function runVerbosityMigrations(database?: Database.Database): void {
+  const targetDb = database || getDatabase()
+
+  targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_verbosity (
+      channel_id TEXT PRIMARY KEY,
+      verbosity TEXT NOT NULL DEFAULT 'tools-and-text',
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `)
+
+  dbLogger.log('Channel verbosity settings migrations complete')
+}
+
+/**
+ * Get the verbosity setting for a channel.
+ * @returns 'tools-and-text' (default) or 'text-only'
+ */
+export function getChannelVerbosity(channelId: string): VerbosityLevel {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT verbosity FROM channel_verbosity WHERE channel_id = ?')
+    .get(channelId) as { verbosity: string } | undefined
+  return (row?.verbosity as VerbosityLevel) || 'tools-and-text'
+}
+
+/**
+ * Set the verbosity setting for a channel.
+ */
+export function setChannelVerbosity(channelId: string, verbosity: VerbosityLevel): void {
+  const db = getDatabase()
+  db.prepare(
+    `INSERT INTO channel_verbosity (channel_id, verbosity, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET verbosity = ?, updated_at = CURRENT_TIMESTAMP`,
+  ).run(channelId, verbosity, verbosity)
+}
+
+/**
+ * Check if automatic worktree creation is enabled for a channel.
+ */
+export function getChannelWorktreesEnabled(channelId: string): boolean {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT enabled FROM channel_worktrees WHERE channel_id = ?')
+    .get(channelId) as { enabled: number } | undefined
+  return row?.enabled === 1
+}
+
+/**
+ * Enable or disable automatic worktree creation for a channel.
+ */
+export function setChannelWorktreesEnabled(channelId: string, enabled: boolean): void {
+  const db = getDatabase()
+  db.prepare(
+    `INSERT INTO channel_worktrees (channel_id, enabled, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET enabled = ?, updated_at = CURRENT_TIMESTAMP`,
+  ).run(channelId, enabled ? 1 : 0, enabled ? 1 : 0)
+}
+
+/**
+ * Get the directory and app_id for a channel from the database.
+ * This is the single source of truth for channel-project mappings.
+ */
+export function getChannelDirectory(channelId: string): {
+  directory: string
+  appId: string | null
+} | undefined {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT directory, app_id FROM channel_directories WHERE channel_id = ?')
+    .get(channelId) as { directory: string; app_id: string | null } | undefined
+
+  if (!row) {
+    return undefined
+  }
+
+  return {
+    directory: row.directory,
+    appId: row.app_id,
+  }
+}
+
 export function closeDatabase(): void {
   if (db) {
     db.close()