@brianli/kimaki 0.4.72-brianli.1

package/src/commands/worktree.ts

@@ -0,0 +1,431 @@
+// 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,
+  REST,
+  type TextChannel,
+  type ThreadChannel,
+  type Message,
+} from 'discord.js'
+import fs from 'node:fs'
+import type { CommandContext } from './types.js'
+import {
+  createPendingWorktree,
+  setWorktreeReady,
+  setWorktreeError,
+  getChannelDirectory,
+  getThreadWorktree,
+} from '../database.js'
+import { SILENT_MESSAGE_FLAGS, reactToThread } from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { notifyError } from '../sentry.js'
+import {
+  createWorktreeWithSubmodules,
+  captureGitDiff,
+  execAsync,
+  type CapturedDiff,
+} from '../worktree-utils.js'
+import { WORKTREE_PREFIX } from './merge-worktree.js'
+import * as errore from 'errore'
+
+const logger = createLogger(LogPrefix.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 opencode/kimaki- prefix.
+ * "My Feature" → "opencode/kimaki-my-feature"
+ * Returns empty string if no valid name can be extracted.
+ */
+export function formatWorktreeName(name: string): string {
+  const formatted = name
+    .toLowerCase()
+    .trim()
+    .replace(/\s+/g, '-')
+    .replace(/[^a-z0-9-]/g, '')
+
+  if (!formatted) {
+    return ''
+  }
+  return `opencode/kimaki-${formatted}`
+}
+
+/**
+ * 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.
+ */
+async function getProjectDirectoryFromChannel(
+  channel: TextChannel,
+  appId: string,
+): Promise<string | WorktreeError> {
+  const channelConfig = await getChannelDirectory(channel.id)
+
+  if (!channelConfig) {
+    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(channelConfig.directory)) {
+    return new WorktreeError(
+      `Directory does not exist: ${channelConfig.directory}`,
+    )
+  }
+
+  return channelConfig.directory
+}
+
+/**
+ * Create worktree in background and update starter message when done.
+ * If diff is provided, it's applied during worktree creation (before submodule init).
+ */
+async function createWorktreeInBackground({
+  thread,
+  starterMessage,
+  worktreeName,
+  projectDirectory,
+  diff,
+  rest,
+}: {
+  thread: ThreadChannel
+  starterMessage: Message
+  worktreeName: string
+  projectDirectory: string
+  diff?: CapturedDiff | null
+  rest: REST
+}): Promise<void> {
+  // Create worktree using git, apply diff, then init submodules
+  logger.log(
+    `Creating worktree "${worktreeName}" for project ${projectDirectory}`,
+  )
+  const worktreeResult = await createWorktreeWithSubmodules({
+    directory: projectDirectory,
+    name: worktreeName,
+    diff,
+  })
+
+  if (worktreeResult instanceof Error) {
+    const errorMsg = worktreeResult.message
+    logger.error('[NEW-WORKTREE] Error:', worktreeResult)
+    await setWorktreeError({ threadId: thread.id, errorMessage: errorMsg })
+    await starterMessage.edit(
+      `🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`,
+    )
+    return
+  }
+
+  // Success - update database and edit starter message
+  await setWorktreeReady({
+    threadId: thread.id,
+    worktreeDirectory: worktreeResult.directory,
+  })
+
+  // React with tree emoji to mark as worktree thread
+  await reactToThread({
+    rest,
+    threadId: thread.id,
+    channelId: thread.parentId || undefined,
+    emoji: '🌳',
+  })
+
+  const diffStatus = diff
+    ? worktreeResult.diffApplied
+      ? '\n✅ Changes applied'
+      : '\n⚠️ Failed to apply changes'
+    : ''
+  await starterMessage.edit(
+    `🌳 **Worktree: ${worktreeName}**\n` +
+      `📁 \`${worktreeResult.directory}\`\n` +
+      `🌿 Branch: \`${worktreeResult.branch}\`` +
+      diffStatus,
+  )
+}
+
+async function findExistingWorktreePath({
+  projectDirectory,
+  worktreeName,
+}: {
+  projectDirectory: string
+  worktreeName: string
+}): Promise<string | undefined | Error> {
+  const listResult = await errore.tryAsync({
+    try: () =>
+      execAsync('git worktree list --porcelain', { cwd: projectDirectory }),
+    catch: (e) => new WorktreeError('Failed to list worktrees', { cause: e }),
+  })
+  if (errore.isError(listResult)) {
+    return listResult
+  }
+
+  const lines = listResult.stdout.split('\n')
+  let currentPath = ''
+  const branchRef = `refs/heads/${worktreeName}`
+
+  for (const line of lines) {
+    if (line.startsWith('worktree ')) {
+      currentPath = line.slice('worktree '.length)
+      continue
+    }
+    if (
+      line.startsWith('branch ') &&
+      line.slice('branch '.length) === branchRef
+    ) {
+      return currentPath || undefined
+    }
+  }
+
+  return undefined
+}
+
+export async function handleNewWorktreeCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  await command.deferReply({ ephemeral: false })
+
+  const channel = command.channel
+  if (!channel) {
+    await command.editReply('Cannot determine channel')
+    return
+  }
+
+  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
+  }
+
+  // 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
+  }
+
+  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
+  }
+
+  const textChannel = channel as TextChannel
+
+  const projectDirectory = await getProjectDirectoryFromChannel(
+    textChannel,
+    appId,
+  )
+  if (errore.isError(projectDirectory)) {
+    await command.editReply(projectDirectory.message)
+    return
+  }
+
+  const existingWorktree = await findExistingWorktreePath({
+    projectDirectory,
+    worktreeName,
+  })
+  if (errore.isError(existingWorktree)) {
+    await command.editReply(existingWorktree.message)
+    return
+  }
+  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_PREFIX}worktree: ${worktreeName}`,
+        autoArchiveDuration: 1440,
+        reason: 'Worktree session',
+      })
+
+      // Add user to thread so it appears in their sidebar
+      await thread.members.add(command.user.id)
+
+      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
+  await 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,
+    rest: command.client.rest,
+  }).catch((e) => {
+    logger.error('[NEW-WORKTREE] Background error:', e)
+    void notifyError(e, 'Background worktree creation failed')
+  })
+}
+
+/**
+ * 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 (await 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 = await getProjectDirectoryFromChannel(
+    parent as TextChannel,
+    appId,
+  )
+  if (errore.isError(projectDirectory)) {
+    await command.editReply(projectDirectory.message)
+    return
+  }
+
+  const existingWorktreePath = await findExistingWorktreePath({
+    projectDirectory,
+    worktreeName,
+  })
+  if (errore.isError(existingWorktreePath)) {
+    await command.editReply(existingWorktreePath.message)
+    return
+  }
+  if (existingWorktreePath) {
+    await command.editReply(
+      `Worktree \`${worktreeName}\` already exists at \`${existingWorktreePath}\``,
+    )
+    return
+  }
+
+  // Capture git diff from project directory before creating worktree.
+  // This allows transferring uncommitted changes to the new worktree.
+  const diff = await captureGitDiff(projectDirectory)
+  const hasDiff = diff && (diff.staged || diff.unstaged)
+
+  // Store pending worktree in database for this existing thread
+  await createPendingWorktree({
+    threadId: thread.id,
+    worktreeName,
+    projectDirectory,
+  })
+
+  // Send status message in thread
+  const diffNote = hasDiff ? '\n📋 Will transfer uncommitted changes' : ''
+  const statusMessage = await thread.send({
+    content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...${diffNote}`,
+    flags: SILENT_MESSAGE_FLAGS,
+  })
+
+  await command.editReply(
+    `Creating worktree \`${worktreeName}\` for this thread...`,
+  )
+
+  // Create worktree in background, passing diff to apply after creation
+  createWorktreeInBackground({
+    thread,
+    starterMessage: statusMessage,
+    worktreeName,
+    projectDirectory,
+    diff,
+    rest: command.client.rest,
+  }).catch((e) => {
+    logger.error('[NEW-WORKTREE] Background error:', e)
+    void notifyError(e, 'Background worktree creation failed (in-thread)')
+  })
+}

package/src/condense-memory.ts

@@ -0,0 +1,36 @@
+// Utility to condense MEMORY.md into a line-numbered table of contents.
+// Separated from opencode-plugin.ts because OpenCode's plugin loader calls
+// every exported function in the module as a plugin initializer — exporting
+// this utility from the plugin entry file caused it to be invoked with a
+// PluginInput object instead of a string, crashing inside marked's Lexer.
+
+import { Lexer } from 'marked'
+
+/**
+ * Condense MEMORY.md into a line-numbered table of contents.
+ * Parses markdown AST with marked's Lexer, emits each heading prefixed by
+ * its source line number, and collapses non-heading content to `...`.
+ * The agent can then use Read with offset/limit to read specific sections.
+ */
+export function condenseMemoryMd(content: string): string {
+  const tokens = new Lexer().lex(content)
+  const lines: string[] = []
+  let charOffset = 0
+  let lastWasEllipsis = false
+
+  for (const token of tokens) {
+    // Compute 1-based line number from character offset
+    const lineNumber = content.slice(0, charOffset).split('\n').length
+    if (token.type === 'heading') {
+      const prefix = '#'.repeat(token.depth)
+      lines.push(`${lineNumber}: ${prefix} ${token.text}`)
+      lastWasEllipsis = false
+    } else if (!lastWasEllipsis) {
+      lines.push('...')
+      lastWasEllipsis = true
+    }
+    charOffset += token.raw.length
+  }
+
+  return lines.join('\n')
+}

package/src/config.ts

@@ -0,0 +1,148 @@
+// Runtime configuration for Kimaki bot.
+// Stores data directory path and provides accessors for other modules.
+// Must be initialized before database or other path-dependent modules are used.
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+const DEFAULT_DATA_DIR = path.join(os.homedir(), '.kimaki')
+
+let dataDir: string | null = null
+
+/**
+ * Get the data directory path.
+ * Falls back to ~/.kimaki if not explicitly set.
+ * Under vitest (KIMAKI_VITEST env var), auto-creates an isolated temp dir so
+ * tests never touch the real ~/.kimaki/ database. Tests that need a specific
+ * dir can still call setDataDir() before any DB access to override this.
+ */
+export function getDataDir(): string {
+  if (!dataDir) {
+    if (process.env.KIMAKI_VITEST) {
+      dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-test-'))
+    } else {
+      dataDir = DEFAULT_DATA_DIR
+    }
+  }
+  return dataDir
+}
+
+/**
+ * Set the data directory path.
+ * Creates the directory if it doesn't exist.
+ * Must be called before any database or path-dependent operations.
+ */
+export function setDataDir(dir: string): void {
+  const resolvedDir = path.resolve(dir)
+
+  if (!fs.existsSync(resolvedDir)) {
+    fs.mkdirSync(resolvedDir, { recursive: true })
+  }
+
+  dataDir = resolvedDir
+}
+
+/**
+ * Get the projects directory path (for /create-new-project command).
+ * Returns <dataDir>/projects
+ */
+export function getProjectsDir(): string {
+  return path.join(getDataDir(), 'projects')
+}
+
+// Default verbosity for channels that haven't set a per-channel override.
+// Set via --verbosity CLI flag at startup.
+import type { VerbosityLevel } from './database.js'
+
+let defaultVerbosity: VerbosityLevel = 'text-and-essential-tools'
+
+export function getDefaultVerbosity(): VerbosityLevel {
+  return defaultVerbosity
+}
+
+export function setDefaultVerbosity(level: VerbosityLevel): void {
+  defaultVerbosity = level
+}
+
+// Default mention mode for channels that haven't set a per-channel override.
+// Set via --mention-mode CLI flag at startup.
+let defaultMentionMode = false
+
+export function getDefaultMentionMode(): boolean {
+  return defaultMentionMode
+}
+
+export function setDefaultMentionMode(enabled: boolean): void {
+  defaultMentionMode = enabled
+}
+
+// Whether critique (diff upload to critique.work) is enabled in system prompts.
+// Enabled by default, disabled via --no-critique CLI flag.
+let critiqueEnabled = true
+
+export function getCritiqueEnabled(): boolean {
+  return critiqueEnabled
+}
+
+export function setCritiqueEnabled(enabled: boolean): void {
+  critiqueEnabled = enabled
+}
+
+// Whether to forward OpenCode server stdout/stderr to kimaki.log.
+// Disabled by default, enabled via --verbose-opencode-server CLI flag.
+let verboseOpencodeServer = false
+
+export function getVerboseOpencodeServer(): boolean {
+  return verboseOpencodeServer
+}
+
+export function setVerboseOpencodeServer(enabled: boolean): void {
+  verboseOpencodeServer = enabled
+}
+
+// Registered user commands, populated by registerCommands() in cli.ts.
+// Stored here (not cli.ts) to avoid circular imports since commands/ modules need this.
+// discordName is the sanitized Discord slash command name (without -cmd suffix),
+// name is the original OpenCode command name (may contain :, /, etc).
+export type RegisteredUserCommand = {
+  name: string
+  discordName: string
+  description: string
+}
+export const registeredUserCommands: RegisteredUserCommand[] = []
+
+const DEFAULT_LOCK_PORT = 29988
+
+/**
+ * Derive a lock port from the data directory path.
+ * If KIMAKI_LOCK_PORT is set to a valid TCP port, it takes precedence.
+ * Returns 29988 for the default ~/.kimaki directory (backwards compatible).
+ * For custom data dirs, uses a hash to generate a port in the range 30000-39999.
+ */
+export function getLockPort(): number {
+  const envPortRaw = process.env['KIMAKI_LOCK_PORT']
+  if (envPortRaw) {
+    const envPort = Number.parseInt(envPortRaw, 10)
+    if (Number.isInteger(envPort) && envPort >= 1 && envPort <= 65535) {
+      return envPort
+    }
+  }
+
+  const dir = getDataDir()
+
+  // Use original port for default data dir (backwards compatible)
+  if (dir === DEFAULT_DATA_DIR) {
+    return DEFAULT_LOCK_PORT
+  }
+
+  // Hash-based port for custom data dirs
+  let hash = 0
+  for (let i = 0; i < dir.length; i++) {
+    const char = dir.charCodeAt(i)
+    hash = (hash << 5) - hash + char
+    hash = hash & hash // Convert to 32bit integer
+  }
+  // Map to port range 30000-39999
+  return 30000 + (Math.abs(hash) % 10000)
+}