kimaki 0.30.1 → 1.0.0

package/src/unnest-code-blocks.ts

@@ -1,185 +0,0 @@
-// Unnest code blocks from list items for Discord.
-// Discord doesn't render code blocks inside lists, so this hoists them
-// to root level while preserving list structure.
-
-import { Lexer, type Token, type Tokens } from 'marked'
-
-type Segment =
-  | { type: 'list-item'; prefix: string; content: string }
-  | { type: 'code'; content: string }
-
-export function unnestCodeBlocksFromLists(markdown: string): string {
-  const lexer = new Lexer()
-  const tokens = lexer.lex(markdown)
-
-  const result: string[] = []
-
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i]!
-    const next = tokens[i + 1]
-
-    const chunk = (() => {
-      if (token.type === 'list') {
-        const segments = processListToken(token as Tokens.List)
-        return renderSegments(segments)
-      }
-      return token.raw
-    })()
-
-    if (!chunk) {
-      continue
-    }
-
-    const nextRaw = next?.raw ?? ''
-    const needsNewline =
-      nextRaw &&
-      !chunk.endsWith('\n') &&
-      typeof nextRaw === 'string' &&
-      !nextRaw.startsWith('\n')
-
-    result.push(needsNewline ? chunk + '\n' : chunk)
-  }
-  return result.join('')
-}
-
-function processListToken(list: Tokens.List): Segment[] {
-  const segments: Segment[] = []
-  const start =
-    typeof list.start === 'number' ? list.start : parseInt(list.start, 10) || 1
-  const prefix = list.ordered ? (i: number) => `${start + i}. ` : () => '- '
-
-  for (let i = 0; i < list.items.length; i++) {
-    const item = list.items[i]!
-    const itemSegments = processListItem(item, prefix(i))
-    segments.push(...itemSegments)
-  }
-
-  return segments
-}
-
-function processListItem(item: Tokens.ListItem, prefix: string): Segment[] {
-  const segments: Segment[] = []
-  let currentText: string[] = []
-  // Track if we've seen a code block - text after code uses continuation prefix
-  let seenCodeBlock = false
-
-  const taskMarker = item.task ? (item.checked ? '[x] ' : '[ ] ') : ''
-  let wroteFirstListItem = false
-
-  const flushText = (): void => {
-    const rawText = currentText.join('')
-    const text = rawText.trimEnd()
-    if (text.trim()) {
-      // After a code block, use '-' as continuation prefix to avoid repeating numbers
-      const effectivePrefix = seenCodeBlock ? '- ' : prefix
-      const marker = !wroteFirstListItem ? taskMarker : ''
-      const normalizedText = normalizeListItemText({
-        text,
-        isTaskItem: item.task,
-      })
-      segments.push({
-        type: 'list-item',
-        prefix: effectivePrefix,
-        content: marker + normalizedText,
-      })
-      wroteFirstListItem = true
-    }
-    currentText = []
-  }
-
-  for (const token of item.tokens) {
-    if (token.type === 'code') {
-      flushText()
-      const codeToken = token as Tokens.Code
-      const lang = codeToken.lang || ''
-      segments.push({
-        type: 'code',
-        content: '```' + lang + '\n' + codeToken.text + '\n```\n',
-      })
-      seenCodeBlock = true
-      continue
-    }
-
-    if (token.type === 'list') {
-      flushText()
-      // Recursively process nested list - segments bubble up
-      const nestedSegments = processListToken(token as Tokens.List)
-      segments.push(...nestedSegments)
-      continue
-    }
-
-    currentText.push(extractText(token))
-  }
-
-  flushText()
-
-  // If no segments were created (empty item), return empty
-  if (segments.length === 0) {
-    return []
-  }
-
-  // If item had no code blocks (all segments are list-items from this level),
-  // return original raw to preserve formatting
-  const hasCode = segments.some((s) => s.type === 'code')
-  if (!hasCode) {
-    return [{ type: 'list-item', prefix: '', content: item.raw }]
-  }
-
-  return segments
-}
-
-function extractText(token: Token): string {
-  // Prefer raw to preserve newlines and markdown markers.
-  if (typeof token.raw === 'string') {
-    return token.raw
-  }
-
-  if (token.type === 'text') {
-    return (token as Tokens.Text).text
-  }
-
-  return ''
-}
-
-function normalizeListItemText({
-  text,
-  isTaskItem,
-}: {
-  text: string
-  isTaskItem: boolean
-}): string {
-  const withoutIndent = text.replace(/^\s+/, '')
-  if (!isTaskItem) {
-    return withoutIndent
-  }
-  return withoutIndent.replace(/^\[(?: |x|X)\]\s+/, '')
-}
-
-function renderSegments(segments: Segment[]): string {
-  const result: string[] = []
-
-  for (let i = 0; i < segments.length; i++) {
-    const segment = segments[i]!
-    const prev = segments[i - 1]
-
-    if (segment.type === 'code') {
-      // Add newline before code if previous was a list item
-      if (prev && prev.type === 'list-item') {
-        result.push('\n')
-      }
-      result.push(segment.content)
-    } else {
-      // list-item
-      if (segment.prefix) {
-        result.push(segment.prefix + segment.content + '\n')
-      } else {
-        // Raw content (no prefix means it's original raw)
-        // Ensure raw ends with newline for proper separation from next segment
-        const raw = segment.content.trimEnd()
-        result.push(raw + '\n')
-      }
-    }
-  }
-
-  return result.join('').trimEnd()
-}

package/src/upgrade.ts

@@ -1,127 +0,0 @@
-// Kimaki self-upgrade utilities.
-// Detects the package manager used to install kimaki, checks npm for newer versions,
-// and runs the global upgrade command. Used by both CLI `kimaki upgrade` and
-// the Discord `/upgrade-and-restart` command, plus background auto-upgrade on startup.
-
-import fs from 'node:fs'
-import { createRequire } from 'node:module'
-import { createLogger, LogPrefix } from './logger.js'
-import { execAsync } from './worktrees.js'
-
-const logger = createLogger(LogPrefix.CLI)
-
-type Pm = 'bun' | 'pnpm' | 'npm'
-
-// Detects which package manager globally installed kimaki, used to run the
-// correct `<pm> i -g kimaki@latest` upgrade command.
-//
-// Detection order:
-// 1. npm_config_user_agent — set by npx/bunx/pnpm dlx, reliable for those cases
-// 2. Realpath of the running script — resolve symlinks and check if the path
-//    lives under a known PM global directory (e.g. ~/.bun, ~/Library/pnpm,
-//    /usr/local/lib/node_modules). Inspired by sindresorhus/global-directory.
-// 3. process.versions.bun — if the runtime itself is Bun, likely bun ecosystem
-// 4. Default to npm — safest fallback since npm is the most common global installer
-export function detectPm(): Pm {
-  const ua = process.env.npm_config_user_agent
-  if (ua?.startsWith('bun/')) {
-    return 'bun'
-  }
-  if (ua?.startsWith('pnpm/')) {
-    return 'pnpm'
-  }
-  if (ua?.startsWith('npm/')) {
-    return 'npm'
-  }
-
-  const scriptPath = resolveScriptRealpath()
-  if (scriptPath) {
-    const p = scriptPath.toLowerCase()
-    // bun global installs live under ~/.bun or $BUN_INSTALL
-    if (p.includes('.bun/') || p.includes('/bun/install/')) {
-      return 'bun'
-    }
-    // pnpm global installs live under ~/Library/pnpm, ~/.local/share/pnpm, or $PNPM_HOME
-    if (p.includes('/pnpm/')) {
-      return 'pnpm'
-    }
-    // npm global installs typically live under lib/node_modules/kimaki without
-    // any pnpm or bun path segments, so if we reach here it's likely npm
-  }
-
-  if (process.versions.bun) {
-    return 'bun'
-  }
-
-  return 'npm'
-}
-
-function resolveScriptRealpath(): string | null {
-  try {
-    const script = process.argv[1]
-    if (!script) {
-      return null
-    }
-    return fs.realpathSync(script)
-  } catch {
-    return null
-  }
-}
-
-export function getCurrentVersion(): string {
-  const require = createRequire(import.meta.url)
-  const pkg = require('../package.json') as { version: string }
-  return pkg.version
-}
-
-export async function getLatestNpmVersion(): Promise<string | null> {
-  try {
-    const res = await fetch('https://registry.npmjs.org/kimaki/latest', {
-      signal: AbortSignal.timeout(15_000),
-    })
-    if (!res.ok) {
-      return null
-    }
-    const data = (await res.json()) as { version: string } | null
-    return data?.version ?? null
-  } catch {
-    return null
-  }
-}
-
-// Returns the new version string if upgraded, null if already up to date.
-export async function upgrade(): Promise<string | null> {
-  const current = getCurrentVersion()
-  const latest = await getLatestNpmVersion()
-  if (!latest) {
-    throw new Error('Failed to check latest version from npm')
-  }
-  if (current === latest) {
-    return null
-  }
-
-  const pm = detectPm()
-  logger.log(`Upgrading kimaki from v${current} to v${latest} using ${pm}...`)
-  await execAsync(`${pm} i -g kimaki@latest`, { timeout: 120_000 })
-
-  return latest
-}
-
-// Fire-and-forget background upgrade check on bot startup.
-// Only upgrades if a newer version is available. Errors are silently ignored.
-export async function backgroundUpgradeKimaki(): Promise<void> {
-  try {
-    const current = getCurrentVersion()
-    const latest = await getLatestNpmVersion()
-    if (!latest || current === latest) {
-      return
-    }
-
-    const pm = detectPm()
-    logger.debug(`Background kimaki upgrade started: v${current} -> v${latest}`)
-    await execAsync(`${pm} i -g kimaki@latest`, { timeout: 120_000 })
-    logger.debug(`Background kimaki upgrade completed: v${latest}`)
-  } catch {
-    // silently ignored, non-critical
-  }
-}

package/src/utils.ts

@@ -1,216 +0,0 @@
-// General utility functions for the bot.
-// Includes Discord OAuth URL generation, array deduplication,
-// abort error detection, and date/time formatting helpers.
-
-import os from 'node:os'
-// Use namespace import for CJS interop — discord.js is CJS and its named
-// exports aren't detectable by all ESM loaders (e.g. tsx/esbuild) because
-// discord.js uses tslib's __exportStar which is opaque to static analysis.
-import * as discord from 'discord.js'
-const { PermissionsBitField } = discord
-import type { BotMode } from './database.js'
-import * as errore from 'errore'
-
-type GenerateInstallUrlOptions = {
-  clientId: string
-  permissions?: bigint[]
-  scopes?: string[]
-  guildId?: string
-  disableGuildSelect?: boolean
-  state?: string
-  redirectUri?: string
-  responseType?: string
-}
-
-export function generateBotInstallUrl({
-  clientId,
-  permissions = [
-    PermissionsBitField.Flags.ViewChannel,
-    PermissionsBitField.Flags.ManageChannels,
-    PermissionsBitField.Flags.SendMessages,
-    PermissionsBitField.Flags.SendMessagesInThreads,
-    PermissionsBitField.Flags.CreatePublicThreads,
-    PermissionsBitField.Flags.ManageThreads,
-    PermissionsBitField.Flags.ReadMessageHistory,
-    PermissionsBitField.Flags.AddReactions,
-    PermissionsBitField.Flags.ManageMessages,
-    PermissionsBitField.Flags.UseExternalEmojis,
-    PermissionsBitField.Flags.AttachFiles,
-    PermissionsBitField.Flags.Connect,
-    PermissionsBitField.Flags.Speak,
-    PermissionsBitField.Flags.ManageRoles,
-    PermissionsBitField.Flags.ManageEvents,
-    PermissionsBitField.Flags.CreateEvents,
-  ],
-  scopes = ['bot', 'applications.commands', 'identify', 'email'],
-  guildId,
-  disableGuildSelect = false,
-  state,
-  redirectUri,
-  responseType,
-}: GenerateInstallUrlOptions): string {
-  const permissionsBitField = new PermissionsBitField(permissions)
-  const permissionsValue = permissionsBitField.bitfield.toString()
-
-  const url = new URL('https://discord.com/api/oauth2/authorize')
-  url.searchParams.set('client_id', clientId)
-  url.searchParams.set('permissions', permissionsValue)
-  url.searchParams.set('scope', scopes.join(' '))
-
-  if (guildId) {
-    url.searchParams.set('guild_id', guildId)
-  }
-
-  if (disableGuildSelect) {
-    url.searchParams.set('disable_guild_select', 'true')
-  }
-
-  if (state) {
-    url.searchParams.set('state', state)
-  }
-
-  if (redirectUri) {
-    url.searchParams.set('redirect_uri', redirectUri)
-  }
-
-  if (responseType) {
-    url.searchParams.set('response_type', responseType)
-  }
-
-  return url.toString()
-}
-
-export const KIMAKI_GATEWAY_APP_ID =
-  process.env.KIMAKI_GATEWAY_APP_ID || '1477605701202481173'
-export const KIMAKI_WEBSITE_URL = process.env.KIMAKI_WEBSITE_URL || 'https://kimaki.dev'
-
-export function generateDiscordInstallUrlForBot({
-  appId,
-  mode,
-  clientId,
-  clientSecret,
-  gatewayCallbackUrl,
-  reachableUrl,
-}: {
-  appId: string
-  mode: BotMode
-  clientId: string | null
-  clientSecret: string | null
-  /** Optional external URL to redirect to after OAuth completes instead of the
-   *  default success page. The website appends ?guild_id=<id> before redirecting. */
-  gatewayCallbackUrl?: string
-  /** When set (KIMAKI_INTERNET_REACHABLE_URL), the website stores this URL in
-   *  gateway_clients.reachable_url so the gateway-proxy connects outbound. */
-  reachableUrl?: string
-}): Error | string {
-  if (mode !== 'gateway') {
-    return generateBotInstallUrl({ clientId: appId })
-  }
-
-  if (!clientId || !clientSecret) {
-    return new Error('Gateway credentials are missing from local database')
-  }
-
-  // In gateway mode, redirect to the website's /discord-install route.
-  // This initiates the better-auth OAuth flow with clientId/clientSecret
-  // as additionalData, which better-auth stores in its verification table
-  // and recovers after Discord redirects back to the callback.
-  // Use a kimaki-specific callback field name to avoid ambiguity with
-  // better-auth's own callbackURL state field.
-  const url = new URL(`${KIMAKI_WEBSITE_URL}/discord-install`)
-  url.searchParams.set('clientId', clientId)
-  url.searchParams.set('clientSecret', clientSecret)
-  if (gatewayCallbackUrl) {
-    url.searchParams.set('kimakiCallbackUrl', gatewayCallbackUrl)
-  }
-  if (reachableUrl) {
-    url.searchParams.set('reachableUrl', reachableUrl)
-  }
-  return url.toString()
-}
-
-export function deduplicateByKey<T, K>(arr: T[], keyFn: (item: T) => K): T[] {
-  const seen = new Set<K>()
-  return arr.filter((item) => {
-    const key = keyFn(item)
-    if (seen.has(key)) {
-      return false
-    }
-    seen.add(key)
-    return true
-  })
-}
-
-// Delegates to errore.isAbortError (walks cause chain for AbortError instances),
-// then falls back to opencode server-specific abort patterns that aren't
-// errore.AbortError but still represent aborted operations.
-export function isAbortError(error: unknown): error is Error {
-  if (errore.isAbortError(error)) return true
-  if (!(error instanceof Error)) return false
-  return (
-    error.name === 'MessageAbortedError' ||
-    error.message?.includes('aborted') === true
-  )
-}
-
-const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' })
-
-const TIME_DIVISIONS: Array<{
-  amount: number
-  name: Intl.RelativeTimeFormatUnit
-}> = [
-  { amount: 60, name: 'seconds' },
-  { amount: 60, name: 'minutes' },
-  { amount: 24, name: 'hours' },
-  { amount: 7, name: 'days' },
-  { amount: 4.34524, name: 'weeks' },
-  { amount: 12, name: 'months' },
-  { amount: Number.POSITIVE_INFINITY, name: 'years' },
-]
-
-export function formatDistanceToNow(date: Date): string {
-  let duration = (date.getTime() - Date.now()) / 1000
-
-  for (const division of TIME_DIVISIONS) {
-    if (Math.abs(duration) < division.amount) {
-      return rtf.format(Math.round(duration), division.name)
-    }
-    duration /= division.amount
-  }
-  return rtf.format(Math.round(duration), 'years')
-}
-
-const dtf = new Intl.DateTimeFormat('en-US', {
-  month: 'short',
-  day: 'numeric',
-  year: 'numeric',
-  hour: 'numeric',
-  minute: '2-digit',
-  hour12: true,
-})
-
-export function formatDateTime(date: Date): string {
-  return dtf.format(date)
-}
-
-// Comprehensive ANSI escape sequence regex covering CSI, OSC, and related sequences.
-// Valid string terminator sequences are BEL, ESC\, and 0x9c.
-const ANSI_REGEX = (() => {
-  const ST = '(?:\\u0007|\\u001B\\u005C|\\u009C)'
-  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`
-  const csi =
-    '[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]'
-  return new RegExp(`${osc}|${csi}`, 'g')
-})()
-
-export function stripAnsi(str: string): string {
-  return str.replace(ANSI_REGEX, '')
-}
-
-export function abbreviatePath(fullPath: string): string {
-  const home = os.homedir()
-  if (fullPath.startsWith(home)) {
-    return '~' + fullPath.slice(home.length)
-  }
-  return fullPath
-}

package/src/voice-attachment.ts

@@ -1,79 +0,0 @@
-// Voice attachment detection helpers.
-// Normalizes Discord attachment heuristics for voice-message detection so
-// message routing, transcription, and empty-prompt guards all agree even when
-// Discord omits contentType on uploaded audio attachments.
-// iOS videos also have duration_secs; reject those before the duration heuristic.
-
-import path from 'node:path'
-
-const VOICE_ATTACHMENT_EXTENSIONS = new Set<string>([
-  '.m4a',
-  '.mp3',
-  '.oga',
-  '.ogg',
-  '.opus',
-  '.wav',
-])
-
-const VIDEO_ATTACHMENT_EXTENSIONS = new Set<string>([
-  '.avi',
-  '.m4v',
-  '.mkv',
-  '.mov',
-  '.mp4',
-  '.webm',
-])
-
-export type VoiceAttachmentLike = {
-  contentType?: string | null
-  name?: string | null
-  duration?: number | null
-  waveform?: string | null
-  width?: number | null
-  height?: number | null
-}
-
-function isVisualMediaAttachment(attachment: VoiceAttachmentLike): boolean {
-  const contentType = attachment.contentType?.trim().toLowerCase() || ''
-  if (contentType.startsWith('video/')) return true
-
-  const extension = path.extname(attachment.name || '').toLowerCase()
-  if (VIDEO_ATTACHMENT_EXTENSIONS.has(extension)) return true
-
-  return (
-    typeof attachment.width === 'number' &&
-    attachment.width > 0 &&
-    typeof attachment.height === 'number' &&
-    attachment.height > 0
-  )
-}
-
-export function getVoiceAttachmentMatchReason(
-  attachment: VoiceAttachmentLike,
-): string | null {
-  if (isVisualMediaAttachment(attachment)) return null
-
-  const contentType = attachment.contentType?.trim().toLowerCase() || ''
-  if (contentType.startsWith('audio/')) {
-    return `contentType:${contentType}`
-  }
-
-  if (typeof attachment.duration === 'number' && attachment.duration > 0) {
-    return `duration:${attachment.duration}`
-  }
-
-  if (attachment.waveform?.trim()) {
-    return 'waveform'
-  }
-
-  const extension = path.extname(attachment.name || '').toLowerCase()
-  if (VOICE_ATTACHMENT_EXTENSIONS.has(extension)) {
-    return `extension:${extension}`
-  }
-
-  return null
-}
-
-export function isVoiceAttachment(attachment: VoiceAttachmentLike): boolean {
-  return getVoiceAttachmentMatchReason(attachment) !== null
-}