kimaki 0.31.0 → 1.1.0

package/src/kimaki-digital-twin.e2e.test.ts

@@ -1,199 +0,0 @@
-// End-to-end test using discord-digital-twin + real Kimaki bot runtime.
-// Verifies onboarding channel creation, message -> thread creation, and assistant reply.
-
-import fs from 'node:fs'
-import path from 'node:path'
-import { expect, test } from 'vitest'
-import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js'
-import { DigitalDiscord } from 'discord-digital-twin/src'
-import { CachedOpencodeProviderProxy } from 'opencode-cached-provider'
-import { setDataDir } from './config.js'
-import { startDiscordBot } from './discord-bot.js'
-import {
-  setBotToken,
-  initDatabase,
-  closeDatabase,
-  setChannelDirectory,
-} from './database.js'
-import { startHranaServer, stopHranaServer } from './hrana-server.js'
-import { cleanupTestSessions, chooseLockPort, initTestGitRepo } from './test-utils.js'
-import { stopOpencodeServer } from './opencode.js'
-
-const geminiApiKey =
-  process.env['GEMINI_API_KEY'] ||
-  process.env['GOOGLE_GENERATIVE_AI_API_KEY'] ||
-  ''
-const geminiModel = process.env['GEMINI_FLASH_MODEL'] || 'gemini-2.5-flash'
-const e2eTest = geminiApiKey.length > 0 ? test : test.skip
-
-function createRunDirectories() {
-  const root = path.resolve(process.cwd(), 'tmp', 'kimaki-digital-twin-e2e')
-  fs.mkdirSync(root, { recursive: true })
-
-  const dataDir = fs.mkdtempSync(path.join(root, 'data-'))
-  const projectDirectory = path.join(root, 'project')
-  const providerCacheDbPath = path.join(root, 'provider-cache.db')
-  fs.mkdirSync(projectDirectory, { recursive: true })
-  initTestGitRepo(projectDirectory)
-
-  return {
-    root,
-    dataDir,
-    projectDirectory,
-    providerCacheDbPath,
-  }
-}
-
-function createDiscordJsClient({ restUrl }: { restUrl: string }) {
-  return new Client({
-    intents: [
-      GatewayIntentBits.Guilds,
-      GatewayIntentBits.GuildMessages,
-      GatewayIntentBits.MessageContent,
-      GatewayIntentBits.GuildVoiceStates,
-    ],
-    partials: [
-      Partials.Channel,
-      Partials.Message,
-      Partials.User,
-      Partials.ThreadMember,
-    ],
-    rest: {
-      api: restUrl,
-      version: '10',
-    },
-  })
-}
-
-e2eTest(
-  'onboarding then message creates thread and assistant reply via digital twin',
-  async () => {
-    const testStartTime = Date.now()
-    const directories = createRunDirectories()
-    const lockPort = chooseLockPort({ key: 'kimaki-digital-twin-e2e' })
-
-    process.env['KIMAKI_LOCK_PORT'] = String(lockPort)
-    setDataDir(directories.dataDir)
-
-    const proxy = new CachedOpencodeProviderProxy({
-      cacheDbPath: directories.providerCacheDbPath,
-      targetBaseUrl: 'https://generativelanguage.googleapis.com/v1beta',
-      apiKey: geminiApiKey,
-      cacheMethods: ['POST'],
-    })
-
-    const testUserId = '100000000000000777'
-    const textChannelId = '100000000000000778'
-    const digitalDiscordDbPath = path.join(
-      directories.dataDir,
-      'digital-discord.db',
-    )
-    const discord = new DigitalDiscord({
-      guild: {
-        name: 'Kimaki E2E Guild',
-        ownerId: testUserId,
-      },
-      channels: [
-        {
-          id: textChannelId,
-          name: 'kimaki-e2e',
-          type: ChannelType.GuildText,
-        },
-      ],
-      users: [
-        {
-          id: testUserId,
-          username: 'e2e-user',
-        },
-      ],
-      dbUrl: `file:${digitalDiscordDbPath}`,
-    })
-
-    let botClient: Client | null = null
-
-    try {
-      await Promise.all([proxy.start(), discord.start()])
-
-      const opencodeConfig = proxy.buildOpencodeConfig({
-        providerName: 'cached-google',
-        providerNpm: '@ai-sdk/google',
-        model: geminiModel,
-        smallModel: geminiModel,
-      })
-      fs.writeFileSync(
-        path.join(directories.projectDirectory, 'opencode.json'),
-        JSON.stringify(opencodeConfig, null, 2),
-      )
-
-      const dbPath = path.join(directories.dataDir, 'discord-sessions.db')
-      const hranaResult = await startHranaServer({ dbPath })
-      if (hranaResult instanceof Error) {
-        throw hranaResult
-      }
-      process.env['KIMAKI_DB_URL'] = hranaResult
-      await initDatabase()
-      await setBotToken(discord.botUserId, discord.botToken)
-
-      await setChannelDirectory({
-        channelId: textChannelId,
-        directory: directories.projectDirectory,
-        channelType: 'text',
-      })
-
-      botClient = createDiscordJsClient({ restUrl: discord.restUrl })
-      await startDiscordBot({
-        token: discord.botToken,
-        appId: discord.botUserId,
-        discordClient: botClient,
-      })
-
-      await discord.channel(textChannelId).user(testUserId).sendMessage({
-        content: 'Reply with exactly: kimaki digital twin ok',
-      })
-
-      const createdThread = await discord.channel(textChannelId).waitForThread({
-        timeout: 60_000,
-        predicate: (thread) => {
-          return thread.name === 'Reply with exactly: kimaki digital twin ok'
-        },
-      })
-
-      const botReply = await discord.thread(createdThread.id).waitForBotReply({
-        timeout: 120_000,
-      })
-
-      expect(createdThread.id.length).toBeGreaterThan(0)
-      expect(botReply.content.trim().length).toBeGreaterThan(0)
-    } finally {
-      await cleanupTestSessions({
-        projectDirectory: directories.projectDirectory,
-        testStartTime,
-      })
-
-      if (botClient) {
-        void botClient.destroy()
-      }
-
-      await stopOpencodeServer()
-      await Promise.all([
-        closeDatabase().catch(() => {
-          return
-        }),
-        stopHranaServer().catch(() => {
-          return
-        }),
-        proxy.stop().catch(() => {
-          return
-        }),
-        discord.stop().catch(() => {
-          return
-        }),
-      ])
-
-      delete process.env['KIMAKI_LOCK_PORT']
-      delete process.env['KIMAKI_DB_URL']
-      fs.rmSync(directories.dataDir, { recursive: true, force: true })
-    }
-  },
-  360_000,
-)

package/src/kimaki-opencode-plugin-loading.e2e.test.ts

@@ -1,208 +0,0 @@
-// E2e test for OpenCode plugin loading.
-// Spawns one `opencode serve` with the same plugin list kimaki writes (its own
-// plugin plus @subrouter/opencode), then checks stderr for load errors and
-// hits the real HTTP API. One server for both plugins, because that is how
-// they actually run, and because booting two costs seconds per file.
-// No Discord infrastructure and no real provider APIs.
-
-import { spawn, type ChildProcess } from 'node:child_process'
-import fs from 'node:fs'
-import path from 'node:path'
-import { createRequire } from 'node:module'
-import { pathToFileURL } from 'node:url'
-import { afterAll, beforeAll, expect, test } from 'vitest'
-import { PROVIDER_IDS, type AuthFile } from '@subrouter/cli'
-import { resolveOpencodeCommand } from './opencode.js'
-import { getSpawnCommandAndArgs } from './opencode-command.js'
-import { chooseLockPort } from './test-utils.js'
-
-const require = createRequire(import.meta.url)
-
-const port = chooseLockPort({ key: 'opencode-plugin-loading-e2e' })
-const projectDir = path.resolve(process.cwd(), 'tmp', 'plugin-loading-e2e')
-const subrouterHome = path.join(projectDir, 'subrouter-home')
-const stderrLines: string[] = []
-
-let serverProcess: ChildProcess | undefined
-
-async function api<T>(routePath: string): Promise<T> {
-  const url = new URL(routePath, `http://127.0.0.1:${port}`)
-  url.searchParams.set('directory', projectDir)
-  const response = await fetch(url, { headers: { 'x-opencode-directory': projectDir } })
-  if (!response.ok) throw new Error(`${routePath} returned ${response.status}`)
-  return (await response.json()) as T
-}
-
-async function waitForHealth() {
-  for (let attempt = 0; attempt < 60; attempt++) {
-    const ok = await fetch(`http://127.0.0.1:${port}/api/health`)
-      .then((r) => r.status < 500)
-      .catch(() => false)
-    if (ok) return true
-    await new Promise((resolve) => {
-      setTimeout(resolve, 500)
-    })
-  }
-  return false
-}
-
-beforeAll(async () => {
-  fs.rmSync(projectDir, { recursive: true, force: true })
-  const opencodeRoot = path.join(projectDir, 'opencode-test-home')
-  const xdgDirectories = {
-    OPENCODE_CONFIG_DIR: path.join(opencodeRoot, '.opencode-kimaki'),
-    XDG_CONFIG_HOME: path.join(opencodeRoot, '.config'),
-    XDG_DATA_HOME: path.join(opencodeRoot, '.local', 'share'),
-    XDG_CACHE_HOME: path.join(opencodeRoot, '.cache'),
-    XDG_STATE_HOME: path.join(opencodeRoot, '.local', 'state'),
-  }
-  ;[...Object.values(xdgDirectories), subrouterHome].forEach((directory) => {
-    fs.mkdirSync(directory, { recursive: true })
-  })
-
-  const { command, args, windowsVerbatimArguments } = getSpawnCommandAndArgs({
-    resolvedCommand: resolveOpencodeCommand(),
-    baseArgs: ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
-  })
-
-  serverProcess = spawn(command, args, {
-    stdio: 'pipe',
-    cwd: projectDir,
-    windowsVerbatimArguments,
-    env: {
-      ...process.env,
-      OPENCODE_CONFIG_CONTENT: JSON.stringify({
-        $schema: 'https://opencode.ai/config.json',
-        lsp: false,
-        formatter: false,
-        plugin: [
-          new URL('../src/kimaki-opencode-plugin.ts', import.meta.url).href,
-          pathToFileURL(require.resolve('@subrouter/opencode')).href,
-        ],
-      }),
-      OPENCODE_TEST_HOME: opencodeRoot,
-      SUBROUTER_HOME: subrouterHome,
-      SUBROUTER_MANUAL_OAUTH: '1',
-      ...xdgDirectories,
-    },
-  })
-
-  serverProcess.stderr?.on('data', (data) => {
-    stderrLines.push(...data.toString().split('\n').filter(Boolean))
-  })
-
-  expect(await waitForHealth()).toBe(true)
-}, 120_000)
-
-afterAll(() => {
-  serverProcess?.kill('SIGTERM')
-})
-
-test('server loads both plugins without errors', () => {
-  const pluginErrorPatterns = [
-    /plugin.*error/i,
-    /failed to load plugin/i,
-    /cannot find module/i,
-    /ERR_MODULE_NOT_FOUND/i,
-    /plugin.*failed/i,
-    /plugin.*crash/i,
-  ]
-  const errorLines = stderrLines.filter((line) => {
-    return pluginErrorPatterns.some((pattern) => {
-      return pattern.test(line)
-    })
-  })
-  expect(errorLines).toEqual([])
-})
-
-test('subrouter is a connected provider so /model accepts subrouter/default', async () => {
-  const providers = await api<{
-    all: Array<{
-      id: string
-      name: string
-      models: Record<
-        string,
-        {
-          name: string
-          capabilities: {
-            attachment: boolean
-            input: { image: boolean; pdf: boolean }
-          }
-        }
-      >
-    }>
-    connected: string[]
-  }>('/provider')
-
-  expect(providers.connected).toContain('subrouter')
-  const subrouter = providers.all.find((entry) => {
-    return entry.id === 'subrouter'
-  })
-  expect(subrouter?.name).toBe('subrouter.org')
-  expect(subrouter?.models.default).toMatchObject({
-    capabilities: {
-      attachment: false,
-      input: { image: false, pdf: false },
-    },
-  })
-})
-
-test('login offers subrouter and asks which subscription to add first', async () => {
-  const methods = await api<
-    Record<
-      string,
-      Array<{
-        type: string
-        label: string
-        prompts?: Array<{ type: string; key: string; options?: Array<{ value: string }> }>
-      }>
-    >
-  >('/provider/auth')
-
-  expect(methods.subrouter).toHaveLength(1)
-  expect(methods.subrouter?.[0]).toMatchObject({ type: 'oauth', label: 'Add a subscription' })
-
-  // Derived from subrouter, not hardcoded: it adds providers over time and a
-  // literal list here just breaks on the next one.
-  const prompt = methods.subrouter?.[0]?.prompts?.[0]
-  expect(prompt).toMatchObject({ type: 'select', key: 'provider' })
-  expect(prompt?.options?.map((option) => option.value)).toEqual([...PROVIDER_IDS])
-})
-
-test('authorize and callback add an opencode-go subscription', async () => {
-  const url = new URL('/provider/subrouter/oauth/authorize', `http://127.0.0.1:${port}`)
-  url.searchParams.set('directory', projectDir)
-  const response = await fetch(url, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', 'x-opencode-directory': projectDir },
-    body: JSON.stringify({ method: 0, inputs: { provider: 'opencode-go' } }),
-  })
-
-  expect(response.ok).toBe(true)
-  const authorization = (await response.json()) as { url: string; method: string; instructions: string }
-  expect(authorization.method).toBe('code')
-  expect(authorization.url).toBe('https://opencode.ai/auth')
-  expect(authorization.instructions).toContain('API key')
-
-  const callbackUrl = new URL(
-    '/provider/subrouter/oauth/callback',
-    `http://127.0.0.1:${port}`,
-  )
-  callbackUrl.searchParams.set('directory', projectDir)
-  const callbackResponse = await fetch(callbackUrl, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'x-opencode-directory': projectDir,
-    },
-    body: JSON.stringify({ method: 0, code: 'zen-key-1' }),
-  })
-
-  expect(callbackResponse.ok).toBe(true)
-  const auth = JSON.parse(
-    fs.readFileSync(path.join(subrouterHome, 'auth.json'), 'utf8'),
-  ) as AuthFile
-  expect(auth.providers['opencode-go']?.accounts).toMatchObject([
-    { type: 'api', key: 'zen-key-1' },
-  ])
-})

package/src/kimaki-opencode-plugin.test.ts

@@ -1,142 +0,0 @@
-import { test, expect, describe } from 'vitest'
-import { condenseMemoryMd } from './condense-memory.js'
-import { sanitizeTaskArguments } from './task-id-plugin.js'
-
-describe('condenseMemoryMd', () => {
-  test('multiple headings with body content', () => {
-    const content = [
-      '# Project Overview',
-      '',
-      'This is a big project with many things.',
-      'It does X, Y, and Z.',
-      '',
-      '## Auth Architecture',
-      '',
-      'JWT tokens with 15min expiry.',
-      'Refresh tokens in httpOnly cookies.',
-      'Session stored in Redis.',
-      '',
-      '## User Preferences',
-      '',
-      '- kebab-case filenames',
-      '- errore-style errors',
-      '- no emojis',
-      '',
-      '### API Conventions',
-      '',
-      'All routes return { data, error }.',
-      'Use spiceflow for the server.',
-      '',
-    ].join('\n')
-
-    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
-      "1: # Project Overview
-      ...
-      6: ## Auth Architecture
-      ...
-      12: ## User Preferences
-      ...
-      18: ### API Conventions
-      ..."
-    `)
-  })
-
-  test('body text before first heading', () => {
-    const content = [
-      'Some preamble notes.',
-      '',
-      '# First Heading',
-      '',
-      'Content here.',
-      '',
-    ].join('\n')
-
-    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
-      "...
-      3: # First Heading
-      ..."
-    `)
-  })
-
-  test('no headings at all', () => {
-    const content = 'Just some notes.\nMore notes.\n'
-    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`"..."`)
-  })
-
-  test('empty content', () => {
-    expect(condenseMemoryMd('')).toMatchInlineSnapshot(`""`)
-  })
-
-  test('consecutive headings without body', () => {
-    const content = [
-      '# H1',
-      '## H2',
-      '### H3',
-      '',
-      'Some body.',
-      '',
-    ].join('\n')
-
-    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
-      "1: # H1
-      2: ## H2
-      3: ### H3
-      ..."
-    `)
-  })
-
-  test('heading with code block body', () => {
-    const content = [
-      '# Config',
-      '',
-      '```json',
-      '{ "key": "value" }',
-      '```',
-      '',
-      '## Notes',
-      '',
-      'Some text.',
-      '',
-    ].join('\n')
-
-    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
-      "1: # Config
-      ...
-      7: ## Notes
-      ..."
-    `)
-  })
-})
-
-describe('sanitizeTaskArguments', () => {
-  test('removes a model-invented UUID task_id', () => {
-    const args = {
-      description: 'inspect repository',
-      prompt: 'Find the implementation',
-      subagent_type: 'explore',
-      task_id: 'ff120f9f-a28d-4d29-b691-b3a5f770759b',
-    }
-
-    sanitizeTaskArguments(args)
-
-    expect(args).toMatchInlineSnapshot(`
-      {
-        "description": "inspect repository",
-        "prompt": "Find the implementation",
-        "subagent_type": "explore",
-      }
-    `)
-  })
-
-  test('keeps an OpenCode session task_id for resume', () => {
-    const args = { task_id: 'ses_child' }
-
-    sanitizeTaskArguments(args)
-
-    expect(args).toMatchInlineSnapshot(`
-      {
-        "task_id": "ses_child",
-      }
-    `)
-  })
-})

package/src/kimaki-opencode-plugin.ts

@@ -1,34 +0,0 @@
-// OpenCode plugin entry point for Kimaki Discord bot.
-// Each export is treated as a separate plugin by OpenCode's plugin loader.
-// CRITICAL: never export utility functions from this file — only plugin
-// initializer functions. OpenCode calls every export as a plugin.
-//
-// Plugins are split into focused modules:
-// - ipc-tools-plugin: file upload, action buttons, and session sleep
-// - context-awareness-plugin: branch, pwd, memory reminder, onboarding tutorial
-// - memory-overview-plugin: frozen MEMORY.md heading overview per session
-// - opencode-interrupt-plugin: interrupt queued messages at step boundaries
-// - kitty-graphics-plugin: extract Kitty Graphics Protocol images from bash output
-// - file-edit-log: record edit/write/apply_patch files per session
-// - bash-tool-schema-plugin: add description and hasSideEffect to bash
-// - task-id-plugin: drop invalid model-generated task resume IDs
-
-export { ipcToolsPlugin } from './ipc-tools-plugin.js'
-export { contextAwarenessPlugin } from './context-awareness-plugin.js'
-export { memoryOverviewPlugin } from './memory-overview-plugin.js'
-export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js'
-// LEGACY per-provider account rotation. Superseded by @subrouter/opencode
-// (registered separately in opencode.ts), which also fails over across
-// providers. These stay because they own `anthropic/*` auth, which opencode
-// itself does not provide. See anthropic-auth-plugin.ts for the full note.
-export { anthropicAuthPlugin } from './anthropic-auth-plugin.js'
-export { openaiRotationPlugin } from './openai-auth-plugin.js'
-export { xaiRotationPlugin } from './xai-auth-plugin.js'
-export { imageOptimizerPlugin } from './image-optimizer-plugin.js'
-export { cacheDriftPlugin } from './cache-drift-plugin.js'
-export { kittyGraphicsPlugin } from 'kitty-graphics-agent'
-export { injectionGuardInternal as injectionGuard } from 'opencode-injection-guard'
-export { kimakiWorkspaceAdaptorPlugin } from './kimaki-workspace-adaptor.js'
-export { fileEditTrackerPlugin } from './file-edit-log.js'
-export { bashToolSchemaPlugin } from './bash-tool-schema-plugin.js'
-export { taskIdPlugin } from './task-id-plugin.js'