kimaki 0.26.0 → 0.28.0

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 })
+}

package/src/format-tables.test.ts

@@ -442,6 +442,107 @@ Done.`)
     `)
   })
 
+  test('renders a single-line callout inside an accented container', () => {
+    const result = splitTablesFromMarkdown(
+      `<callout accent="#f59e0b">Full suite: **622 passed, 6 unrelated existing failures, 8 skipped**.</callout>`,
+    )
+    expect(result.map((segment) => segment.type)).toEqual(['components'])
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "components": [
+            {
+              "accent_color": 16096779,
+              "components": [
+                {
+                  "content": "Full suite: **622 passed, 6 unrelated existing failures, 8 skipped**.",
+                  "type": 10,
+                },
+              ],
+              "type": 17,
+            },
+          ],
+          "type": "components",
+        },
+      ]
+    `)
+  })
+
+  test('splits text around a single-line callout into separate segments', () => {
+    const result = splitTablesFromMarkdown(`Done.
+
+<callout accent="#f59e0b">Confidence: high.</callout>
+
+Diff: https://critique.work/v/example`)
+    expect(result.map((segment) => segment.type)).toEqual([
+      'text',
+      'components',
+      'text',
+    ])
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "Done.
+
+      ",
+          "type": "text",
+        },
+        {
+          "components": [
+            {
+              "accent_color": 16096779,
+              "components": [
+                {
+                  "content": "Confidence: high.",
+                  "type": 10,
+                },
+              ],
+              "type": 17,
+            },
+          ],
+          "type": "components",
+        },
+        {
+          "text": "
+      Diff: https://critique.work/v/example",
+          "type": "text",
+        },
+      ]
+    `)
+  })
+
+  test('preserves single-line callout syntax inside fenced code', () => {
+    const result = splitTablesFromMarkdown(`\`\`\`html
+<callout accent="#f59e0b">inside</callout>
+\`\`\``)
+    expect(result.map((segment) => segment.type)).toEqual(['text'])
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "\`\`\`html
+      <callout accent="#f59e0b">inside</callout>
+      \`\`\`",
+          "type": "text",
+        },
+      ]
+    `)
+  })
+
+  test('keeps malformed single-line callouts as plain text', () => {
+    const result = splitTablesFromMarkdown(
+      `<callout accent="#f59e0b">content</callout></callout>`,
+    )
+    expect(result.map((segment) => segment.type)).toEqual(['text'])
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "<callout accent="#f59e0b">content</callout></callout>",
+          "type": "text",
+        },
+      ]
+    `)
+  })
+
   test('renders callout text inside an accented container', () => {
     const result = splitTablesFromMarkdown(`<callout accent="#2b7fff">
 ## Important