kimaki 0.26.0 → 0.27.0

package/src/discord-utils.ts

@@ -254,12 +254,6 @@ export async function archiveThread({
     if (updateResult instanceof Error) {
       discordLogger.warn(`[archive-thread] ${updateResult.message}`)
     }
-
-    const abortResult = await client.session.abort({ sessionID: sessionId })
-      .catch((e) => new Error('Failed to abort session', { cause: e }))
-    if (abortResult instanceof Error) {
-      discordLogger.warn(`[archive-thread] ${abortResult.message}`)
-    }
   }
 
   if (archiveDelay > 0) {
@@ -275,6 +269,27 @@ export async function archiveThread({
   })
 }
 
+export const DISCORD_THREAD_RENAME_TIMEOUT_MS = 3000
+
+// Discord rename can hang on the 3rd call (~2 per 10 min). Race so it never blocks.
+export async function raceDiscordRename<T>({
+  rename,
+  timeoutMs = DISCORD_THREAD_RENAME_TIMEOUT_MS,
+}: {
+  rename: Promise<T>
+  timeoutMs?: number
+}): Promise<T | 'timeout'> {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs)
+  return Promise.race([
+    rename,
+    new Promise<'timeout'>((resolve) => {
+      timeoutSignal.addEventListener('abort', () => {
+        resolve('timeout')
+      })
+    }),
+  ])
+}
+
 /**
  * Add a user as a thread member so the thread shows up in their Discord left
  * sidebar. Discord only lists threads you are a member of, so a scheduled

package/src/errors.ts

@@ -117,6 +117,11 @@ export class OpenCodeSdkError extends errore.createTaggedError({
   message: 'OpenCode SDK call failed: $operation',
 }) {}
 
+export class InvalidModelError extends errore.createTaggedError({
+  name: 'InvalidModelError',
+  message: 'Invalid model "$model": $reason',
+}) {}
+
 export class FilesystemOperationError extends errore.createTaggedError({
   name: 'FilesystemOperationError',
   message: 'Filesystem operation failed: $operation',

package/src/exec-async.ts

@@ -1,32 +1,41 @@
-import { exec } from 'node:child_process'
+import { exec, execFile } from 'node:child_process'
 import { promisify } from 'node:util'
 
 const DEFAULT_EXEC_TIMEOUT_MS = 10_000
 
 const _execAsync = promisify(exec)
+const _execFileAsync = promisify(execFile)
 
 export function execAsync(
-  command: string,
+  command: string | { command: string; args: string[] },
   options?: Parameters<typeof _execAsync>[1],
 ): Promise<{ stdout: string; stderr: string }> {
-  const timeoutMs =
-    (options as { timeout?: number })?.timeout || DEFAULT_EXEC_TIMEOUT_MS
-  const execPromise = _execAsync(command, options) as Promise<{
-    stdout: string
-    stderr: string
-  }> & { child?: import('node:child_process').ChildProcess }
+  const timeoutMs = options?.timeout || DEFAULT_EXEC_TIMEOUT_MS
+  const childPromise =
+    typeof command === 'string'
+      ? _execAsync(command, options)
+      : _execFileAsync(command.command, command.args, options)
+  const execPromise = childPromise.then(({ stdout, stderr }) => {
+    return {
+      stdout: typeof stdout === 'string' ? stdout : stdout.toString(),
+      stderr: typeof stderr === 'string' ? stderr : stderr.toString(),
+    }
+  })
+  const commandLabel = typeof command === 'string'
+    ? command
+    : [command.command, ...command.args].join(' ')
   let timer: ReturnType<typeof setTimeout> | undefined
   const timeoutPromise = new Promise<never>((_, reject) => {
     timer = setTimeout(() => {
-      const pid = execPromise.child?.pid
+      const pid = childPromise.child?.pid
       if (pid) {
         try {
           process.kill(-pid, 'SIGTERM')
         } catch {
-          execPromise.child?.kill('SIGTERM')
+          childPromise.child?.kill('SIGTERM')
         }
       }
-      reject(new Error(`Command timed out after ${timeoutMs}ms: ${command}`))
+      reject(new Error(`Command timed out after ${timeoutMs}ms: ${commandLabel}`))
     }, timeoutMs)
   })
   return Promise.race([execPromise, timeoutPromise]).finally(() => {

package/src/external-directory-permissions.e2e.test.ts

@@ -85,14 +85,14 @@ describe('external directory permissions', () => {
       ⬥ reading external directory
       ┣ read *probe.txt*
       ⬥ external-directory-probe-done
-      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>
       --- from: user (external-directory-tester)
       EXTERNAL_DIRECTORY_PROBE_MARKER followup
       --- from: assistant (TestBot)
       ⬥ reading external directory
       ┣ read *probe.txt*
       ⬥ external-directory-probe-done
-      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
     `)
     expect(text).not.toContain('Permission Required')
   })

package/src/file-edit-log.test.ts

@@ -0,0 +1,287 @@
+// Tests for file-edit event extraction, derivation, and JSONL persistence.
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, test } from 'vitest'
+import {
+  appendFileEditEvents,
+  createFileEditHooks,
+  editorsForFile,
+  extractEditedFiles,
+  loadFileEditEvents,
+  type FileEditEvent,
+} from './file-edit-log.js'
+
+const tempDirs: string[] = []
+
+function makeDataDir() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-file-edit-log-'))
+  tempDirs.push(dir)
+  return dir
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+function event(partial: Partial<FileEditEvent> & Pick<FileEditEvent, 'sessionId' | 'file'>): FileEditEvent {
+  return {
+    v: 1,
+    at: 1,
+    tool: 'edit',
+    ...partial,
+  }
+}
+
+describe('extractEditedFiles', () => {
+  test('extracts edit and write filePath and ignores other tools', () => {
+    expect(
+      extractEditedFiles({
+        tool: 'edit',
+        args: { filePath: 'src/foo.ts' },
+        directory: '/repo',
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "/repo/src/foo.ts",
+      ]
+    `)
+    expect(
+      extractEditedFiles({
+        tool: 'write',
+        args: { filePath: '/abs/bar.ts' },
+        directory: '/repo',
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "/abs/bar.ts",
+      ]
+    `)
+    expect(
+      extractEditedFiles({
+        tool: 'read',
+        args: { filePath: 'src/foo.ts' },
+        directory: '/repo',
+      }),
+    ).toMatchInlineSnapshot(`
+      []
+    `)
+    expect(
+      extractEditedFiles({
+        tool: 'bash',
+        args: {},
+        directory: '/repo',
+      }),
+    ).toMatchInlineSnapshot(`
+      []
+    `)
+  })
+
+  test('extracts apply_patch paths and resolves them against directory', () => {
+    const patchText = [
+      '*** Begin Patch',
+      '*** Update File: src/foo.ts',
+      '@@',
+      '-a',
+      '+b',
+      '*** Add File: src/bar.ts',
+      '+hello',
+      '*** Delete File: src/old.ts',
+      '*** Move to: src/renamed.ts',
+      '*** End Patch',
+    ].join('\n')
+
+    expect(
+      extractEditedFiles({
+        tool: 'apply_patch',
+        args: { patchText },
+        directory: '/repo',
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "/repo/src/foo.ts",
+        "/repo/src/bar.ts",
+        "/repo/src/old.ts",
+        "/repo/src/renamed.ts",
+      ]
+    `)
+  })
+})
+
+describe('editorsForFile', () => {
+  test('orders unique sessions by last edit and matches relative paths', () => {
+    const events: FileEditEvent[] = [
+      event({ sessionId: 'ses_old', file: '/repo/src/foo.ts', at: 10 }),
+      event({ sessionId: 'ses_other', file: '/repo/src/other.ts', at: 50 }),
+      event({ sessionId: 'ses_new', file: '/repo/src/foo.ts', at: 20 }),
+      event({ sessionId: 'ses_old', file: '/repo/src/foo.ts', at: 40, tool: 'write' }),
+    ]
+
+    expect(
+      editorsForFile({
+        events,
+        filePath: 'src/foo.ts',
+        cwd: '/repo',
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "at": 40,
+          "sessionId": "ses_old",
+        },
+        {
+          "at": 20,
+          "sessionId": "ses_new",
+        },
+      ]
+    `)
+  })
+})
+
+describe('file edit jsonl log', () => {
+  test('appends events and loads them back', () => {
+    const dataDir = makeDataDir()
+    const first: FileEditEvent[] = [
+      event({ sessionId: 'ses_a', file: '/repo/a.ts', at: 1 }),
+    ]
+    const second: FileEditEvent[] = [
+      event({ sessionId: 'ses_b', file: '/repo/b.ts', at: 2, tool: 'write' }),
+    ]
+
+    const appended = appendFileEditEvents({ dataDir, events: first })
+    if (appended instanceof Error) throw appended
+    const appendedAgain = appendFileEditEvents({ dataDir, events: second })
+    if (appendedAgain instanceof Error) throw appendedAgain
+
+    const loaded = loadFileEditEvents({ dataDir })
+    if (loaded instanceof Error) throw loaded
+    expect(loaded).toMatchInlineSnapshot(`
+      [
+        {
+          "at": 1,
+          "file": "/repo/a.ts",
+          "sessionId": "ses_a",
+          "tool": "edit",
+          "v": 1,
+        },
+        {
+          "at": 2,
+          "file": "/repo/b.ts",
+          "sessionId": "ses_b",
+          "tool": "write",
+          "v": 1,
+        },
+      ]
+    `)
+  })
+
+  test('compacts to the newest events when the log is too large', () => {
+    const dataDir = makeDataDir()
+    const events: FileEditEvent[] = [
+      event({ sessionId: 'ses_1', file: '/repo/a.ts', at: 1 }),
+      event({ sessionId: 'ses_2', file: '/repo/b.ts', at: 2 }),
+      event({ sessionId: 'ses_3', file: '/repo/c.ts', at: 3 }),
+    ]
+    const appended = appendFileEditEvents({
+      dataDir,
+      events,
+      maxEvents: 2,
+      compactAfterBytes: 1,
+    })
+    if (appended instanceof Error) throw appended
+
+    const loaded = loadFileEditEvents({ dataDir })
+    if (loaded instanceof Error) throw loaded
+    expect(loaded).toMatchInlineSnapshot(`
+      [
+        {
+          "at": 2,
+          "file": "/repo/b.ts",
+          "sessionId": "ses_2",
+          "tool": "edit",
+          "v": 1,
+        },
+        {
+          "at": 3,
+          "file": "/repo/c.ts",
+          "sessionId": "ses_3",
+          "tool": "edit",
+          "v": 1,
+        },
+      ]
+    `)
+  })
+
+  test('compacts repeated edits of the same session and file to one row', () => {
+    const dataDir = makeDataDir()
+    const events: FileEditEvent[] = [
+      event({ sessionId: 'ses_a', file: '/repo/a.ts', at: 1 }),
+      event({ sessionId: 'ses_a', file: '/repo/a.ts', at: 2, tool: 'write' }),
+      event({ sessionId: 'ses_a', file: '/repo/a.ts', at: 3 }),
+    ]
+    const appended = appendFileEditEvents({
+      dataDir,
+      events,
+      maxEvents: 10,
+      compactAfterBytes: 1,
+    })
+    if (appended instanceof Error) throw appended
+
+    const loaded = loadFileEditEvents({ dataDir })
+    if (loaded instanceof Error) throw loaded
+    expect(loaded).toMatchInlineSnapshot(`
+      [
+        {
+          "at": 3,
+          "file": "/repo/a.ts",
+          "sessionId": "ses_a",
+          "tool": "edit",
+          "v": 1,
+        },
+      ]
+    `)
+  })
+})
+
+describe('fileEditTrackerPlugin', () => {
+  test('records edit and apply_patch and ignores bash', async () => {
+    const dataDir = makeDataDir()
+    const hooks = createFileEditHooks({ dataDir, directory: '/repo' })
+    await hooks['tool.execute.after']({
+      tool: 'edit',
+      sessionID: 'ses_x',
+      args: { filePath: 'src/a.ts' },
+    })
+    await hooks['tool.execute.after']({
+      tool: 'apply_patch',
+      sessionID: 'ses_x',
+      args: { patchText: '*** Update File: src/b.ts\n' },
+    })
+    await hooks['tool.execute.after']({
+      tool: 'bash',
+      sessionID: 'ses_x',
+      args: {},
+    })
+    const loaded = loadFileEditEvents({ dataDir })
+    if (loaded instanceof Error) throw loaded
+    expect(loaded.map((entry) => {
+      return { sessionId: entry.sessionId, file: entry.file, tool: entry.tool }
+    })).toMatchInlineSnapshot(`
+      [
+        {
+          "file": "/repo/src/a.ts",
+          "sessionId": "ses_x",
+          "tool": "edit",
+        },
+        {
+          "file": "/repo/src/b.ts",
+          "sessionId": "ses_x",
+          "tool": "apply_patch",
+        },
+      ]
+    `)
+  })
+})

package/src/file-edit-log.ts

@@ -0,0 +1,283 @@
+// Tracks which OpenCode sessions last edited each file.
+// Plugin appends JSONL events; CLI derives the per-file session list on read.
+
+import type { Plugin } from '@opencode-ai/plugin'
+import fs from 'node:fs'
+import path from 'node:path'
+import * as errore from 'errore'
+import { FilesystemOperationError } from './errors.js'
+import { extractPatchFilePaths } from './patch-text-parser.js'
+import { createPluginLogger, setPluginLogFilePath } from './plugin-logger.js'
+
+const logger = createPluginLogger('FILEEDIT')
+
+export const FILE_EDIT_EVENTS_FILENAME = 'file-edit-events.jsonl'
+const DEFAULT_MAX_EVENTS = 10_000
+const DEFAULT_COMPACT_AFTER_BYTES = 5 * 1024 * 1024
+
+export type FileEditTool = 'edit' | 'write' | 'apply_patch'
+
+export type FileEditEvent = {
+  v: 1
+  at: number
+  sessionId: string
+  file: string
+  tool: FileEditTool
+}
+
+function isFileEditTool(tool: string): tool is FileEditTool {
+  return tool === 'edit' || tool === 'write' || tool === 'apply_patch'
+}
+
+type ToolArgs = {
+  filePath?: string
+  patchText?: string
+}
+
+function getStringField({ args, key }: { args: ToolArgs; key: keyof ToolArgs }) {
+  const value = args[key]
+  return typeof value === 'string' ? value : ''
+}
+
+export function extractEditedFiles({
+  tool,
+  args,
+  directory,
+}: {
+  tool: string
+  args: ToolArgs
+  directory: string
+}) {
+  const name = tool.toLowerCase()
+  if (name === 'edit' || name === 'write') {
+    const filePath = getStringField({ args, key: 'filePath' })
+    if (!filePath) return []
+    return [path.resolve(directory, filePath)]
+  }
+  if (name !== 'apply_patch') return []
+  const patchText = getStringField({ args, key: 'patchText' })
+  if (!patchText) return []
+  return extractPatchFilePaths(patchText).map((filePath) => {
+    return path.resolve(directory, filePath)
+  })
+}
+
+export function editorsForFile({
+  events,
+  filePath,
+  cwd,
+}: {
+  events: FileEditEvent[]
+  filePath: string
+  cwd: string
+}) {
+  const resolved = path.resolve(cwd, filePath)
+  const latestBySession = new Map<string, number>()
+  for (const event of events) {
+    if (path.resolve(event.file) !== resolved) continue
+    const previous = latestBySession.get(event.sessionId)
+    if (previous === undefined || event.at > previous) {
+      latestBySession.set(event.sessionId, event.at)
+    }
+  }
+  return [...latestBySession.entries()]
+    .map(([sessionId, at]) => {
+      return { sessionId, at }
+    })
+    .sort((left, right) => {
+      return right.at - left.at
+    })
+}
+
+function parseFileEditEvent(line: string) {
+  const parsed = errore.try(
+    () => JSON.parse(line) as {
+      v: number
+      at: number
+      sessionId: string
+      file: string
+      tool: string
+    },
+    (cause) => new FilesystemOperationError({ operation: 'parse file edit event', cause }),
+  )
+  if (parsed instanceof Error) return null
+  if (!parsed || typeof parsed !== 'object') return null
+  if (parsed.v !== 1) return null
+  if (typeof parsed.at !== 'number' || !Number.isFinite(parsed.at)) return null
+  if (typeof parsed.sessionId !== 'string' || parsed.sessionId.length === 0) return null
+  if (typeof parsed.file !== 'string' || parsed.file.length === 0) return null
+  if (typeof parsed.tool !== 'string' || !isFileEditTool(parsed.tool)) return null
+  return {
+    v: 1 as const,
+    at: parsed.at,
+    sessionId: parsed.sessionId,
+    file: parsed.file,
+    tool: parsed.tool,
+  }
+}
+
+function nodeErrorCode(error: Error) {
+  const cause = error.cause
+  if (!cause || typeof cause !== 'object') return ''
+  const code = Reflect.get(cause, 'code')
+  return typeof code === 'string' ? code : ''
+}
+
+export function loadFileEditEvents({ dataDir }: { dataDir: string }) {
+  const logPath = path.join(dataDir, FILE_EDIT_EVENTS_FILENAME)
+  const raw = errore.try(
+    () => fs.readFileSync(logPath, 'utf8'),
+    (cause) => new FilesystemOperationError({ operation: 'read file edit log', cause }),
+  )
+  if (raw instanceof Error) {
+    if (nodeErrorCode(raw) === 'ENOENT') return []
+    return raw
+  }
+  const events: FileEditEvent[] = []
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue
+    const event = parseFileEditEvent(line)
+    if (event) events.push(event)
+  }
+  return events
+}
+
+function collapseFileEditEvents(events: FileEditEvent[]) {
+  const latest = new Map<string, FileEditEvent>()
+  for (const event of events) {
+    const key = `${event.sessionId}\0${event.file}`
+    const previous = latest.get(key)
+    if (!previous || event.at >= previous.at) latest.set(key, event)
+  }
+  return [...latest.values()].sort((left, right) => {
+    return left.at - right.at
+  })
+}
+
+function compactFileEditLog({
+  dataDir,
+  maxEvents,
+}: {
+  dataDir: string
+  maxEvents: number
+}) {
+  const loaded = loadFileEditEvents({ dataDir })
+  if (loaded instanceof Error) return loaded
+  const collapsed = collapseFileEditEvents(loaded)
+  const kept = collapsed.length > maxEvents ? collapsed.slice(-maxEvents) : collapsed
+  const logPath = path.join(dataDir, FILE_EDIT_EVENTS_FILENAME)
+  const tempPath = `${logPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
+  const body = kept.map((event) => `${JSON.stringify(event)}\n`).join('')
+  const written = errore.try(
+    () => {
+      fs.writeFileSync(tempPath, body)
+      fs.renameSync(tempPath, logPath)
+    },
+    (cause) => new FilesystemOperationError({ operation: 'compact file edit log', cause }),
+  )
+  if (written instanceof Error) {
+    fs.rmSync(tempPath, { force: true })
+    return written
+  }
+}
+
+export function appendFileEditEvents({
+  dataDir,
+  events,
+  maxEvents = DEFAULT_MAX_EVENTS,
+  compactAfterBytes = DEFAULT_COMPACT_AFTER_BYTES,
+}: {
+  dataDir: string
+  events: FileEditEvent[]
+  maxEvents?: number
+  compactAfterBytes?: number
+}) {
+  if (events.length === 0) return
+  const logPath = path.join(dataDir, FILE_EDIT_EVENTS_FILENAME)
+  const prepared = errore.try(
+    () => {
+      fs.mkdirSync(dataDir, { recursive: true })
+      fs.appendFileSync(logPath, events.map((event) => `${JSON.stringify(event)}\n`).join(''))
+    },
+    (cause) => new FilesystemOperationError({ operation: 'append file edit log', cause }),
+  )
+  if (prepared instanceof Error) return prepared
+  const size = errore.try(
+    () => fs.statSync(logPath).size,
+    (cause) => new FilesystemOperationError({ operation: 'stat file edit log', cause }),
+  )
+  if (size instanceof Error) return size
+  if (size < compactAfterBytes) return
+  return compactFileEditLog({ dataDir, maxEvents })
+}
+
+function recordToolEdits({
+  dataDir,
+  directory,
+  sessionId,
+  tool,
+  args,
+}: {
+  dataDir: string
+  directory: string
+  sessionId: string
+  tool: string
+  args: ToolArgs
+}) {
+  const name = tool.toLowerCase()
+  if (!isFileEditTool(name)) return
+  const files = extractEditedFiles({ tool: name, args, directory })
+  if (files.length === 0) return
+  const at = Date.now()
+  const events = files.map((file) => {
+    return {
+      v: 1 as const,
+      at,
+      sessionId,
+      file,
+      tool: name,
+    }
+  })
+  const result = appendFileEditEvents({ dataDir, events })
+  if (result instanceof Error) {
+    logger.warn('Failed to record file edit', result.message)
+  }
+}
+
+export function createFileEditHooks({
+  dataDir,
+  directory,
+}: {
+  dataDir: string
+  directory: string
+}) {
+  return {
+    'tool.execute.after': async (input: {
+      tool: string
+      sessionID: string
+      args: ToolArgs
+    }) => {
+      recordToolEdits({
+        dataDir,
+        directory,
+        sessionId: input.sessionID,
+        tool: input.tool,
+        args: input.args,
+      })
+    },
+  }
+}
+
+export const fileEditTrackerPlugin: Plugin = async ({ directory }) => {
+  const dataDir = process.env.KIMAKI_DATA_DIR
+  if (!dataDir) return {}
+  setPluginLogFilePath(dataDir)
+  const created = errore.try(
+    () => fs.mkdirSync(dataDir, { recursive: true }),
+    (cause) => new FilesystemOperationError({ operation: 'create file edit log dir', cause }),
+  )
+  if (created instanceof Error) {
+    logger.warn('Failed to create file edit log dir', created.message)
+  }
+  return createFileEditHooks({ dataDir, directory })
+}