kimaki 0.26.0 → 0.27.0

package/dist/file-edit-log.js

@@ -0,0 +1,197 @@
+// Tracks which OpenCode sessions last edited each file.
+// Plugin appends JSONL events; CLI derives the per-file session list on read.
+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;
+function isFileEditTool(tool) {
+    return tool === 'edit' || tool === 'write' || tool === 'apply_patch';
+}
+function getStringField({ args, key }) {
+    const value = args[key];
+    return typeof value === 'string' ? value : '';
+}
+export function extractEditedFiles({ tool, args, directory, }) {
+    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, }) {
+    const resolved = path.resolve(cwd, filePath);
+    const latestBySession = new Map();
+    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) {
+    const parsed = errore.try(() => JSON.parse(line), (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,
+        at: parsed.at,
+        sessionId: parsed.sessionId,
+        file: parsed.file,
+        tool: parsed.tool,
+    };
+}
+function nodeErrorCode(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 }) {
+    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 = [];
+    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) {
+    const latest = new Map();
+    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, }) {
+    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, }) {
+    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, }) {
+    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,
+            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, }) {
+    return {
+        'tool.execute.after': async (input) => {
+            recordToolEdits({
+                dataDir,
+                directory,
+                sessionId: input.sessionID,
+                tool: input.tool,
+                args: input.args,
+            });
+        },
+    };
+}
+export const fileEditTrackerPlugin = 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/dist/file-edit-log.test.js

@@ -0,0 +1,258 @@
+// 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, } from './file-edit-log.js';
+const tempDirs = [];
+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) {
+    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 = [
+            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 = [
+            event({ sessionId: 'ses_a', file: '/repo/a.ts', at: 1 }),
+        ];
+        const second = [
+            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 = [
+            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 = [
+            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/dist/format-tables.js

@@ -173,8 +173,30 @@ function splitMarkdownByCallouts({ markdown, }) {
     }) ?? [markdown];
     const blocks = [];
     let textBuffer = '';
+    let fence = null;
     for (let index = 0; index < lines.length; index++) {
         const line = lines[index];
+        if (fence) {
+            textBuffer += line;
+            if (isMarkdownFenceClose({ line, fence }))
+                fence = null;
+            continue;
+        }
+        const openingFence = parseMarkdownFenceOpen({ line });
+        if (openingFence) {
+            fence = openingFence;
+            textBuffer += line;
+            continue;
+        }
+        const singleLineCallout = parseSingleLineCallout({ line });
+        if (singleLineCallout) {
+            if (textBuffer.length > 0) {
+                blocks.push({ type: 'text', text: textBuffer });
+                textBuffer = '';
+            }
+            blocks.push(singleLineCallout);
+            continue;
+        }
         const callout = parseCalloutOpenLine({ line });
         if (!callout) {
             textBuffer += line;
@@ -338,6 +360,36 @@ function collectCalloutBodyFromLines({ lines, startIndex, }) {
     }
     return new Error('Unclosed <callout> block');
 }
+function parseMarkdownFenceOpen({ line, }) {
+    const marker = line.match(/^ {0,3}(`{3,}|~{3,})/)?.[1];
+    if (!marker)
+        return null;
+    return {
+        marker: marker.startsWith('`') ? '`' : '~',
+        length: marker.length,
+    };
+}
+function isMarkdownFenceClose({ line, fence, }) {
+    const marker = line.trim();
+    return marker.length >= fence.length &&
+        [...marker].every((character) => character === fence.marker);
+}
+function parseSingleLineCallout({ line, }) {
+    const match = line.trim().match(/^(<callout(?:\s+[^>]*)?>)(.*?)<\/callout>$/i);
+    if (!match)
+        return null;
+    const content = match[2];
+    if (/<\/?callout(?:\s|>)/i.test(content))
+        return null;
+    const callout = parseCalloutOpenLine({ line: match[1] });
+    if (!callout)
+        return null;
+    return {
+        type: 'callout',
+        content,
+        callout,
+    };
+}
 function parseCalloutOpenLine({ line, }) {
     const match = line.trim().match(/^<callout(?:\s+[^>]*)?>$/i);
     if (!match) {

package/dist/format-tables.test.js

@@ -409,6 +409,99 @@ 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

package/dist/gateway-proxy-reconnect.e2e.test.js

@@ -238,6 +238,24 @@ function waitForClientReady({ client, token, timeoutMs = 30_000, }) {
         client.login(token).catch(reject);
     });
 }
+function waitForGatewayUnavailable({ client, timeoutMs = 10_000, }) {
+    return new Promise((resolve, reject) => {
+        let reconnectAttempts = 0;
+        const timeout = setTimeout(() => {
+            client.off(Events.ShardReconnecting, onReconnecting);
+            reject(new Error(`Client did not observe gateway unavailability within ${timeoutMs}ms`));
+        }, timeoutMs);
+        const onReconnecting = () => {
+            reconnectAttempts += 1;
+            if (reconnectAttempts < 2)
+                return;
+            clearTimeout(timeout);
+            client.off(Events.ShardReconnecting, onReconnecting);
+            resolve();
+        };
+        client.on(Events.ShardReconnecting, onReconnecting);
+    });
+}
 function waitForReconnection({ client, events, label, timeoutMs = 30_000, }) {
     return new Promise((resolve) => {
         const timeout = setTimeout(() => {
@@ -245,14 +263,14 @@ function waitForReconnection({ client, events, label, timeoutMs = 30_000, }) {
             console.log(`[${label}] Events so far:`, events);
             resolve(false);
         }, timeoutMs);
-        client.on(Events.ShardReady, () => {
+        const finish = () => {
             clearTimeout(timeout);
+            client.off(Events.ShardReady, finish);
+            client.off(Events.ShardResume, finish);
             resolve(true);
-        });
-        client.on(Events.ShardResume, () => {
-            clearTimeout(timeout);
-            resolve(true);
-        });
+        };
+        client.on(Events.ShardReady, finish);
+        client.on(Events.ShardResume, finish);
     });
 }
 // ============================================================================
@@ -315,13 +333,15 @@ describeLocal('gateway-proxy reconnection (local binary)', () => {
         console.log('[local] Client ready');
         // Kill proxy
         const firstProxy = proxyProcess;
+        const gatewayUnavailable = waitForGatewayUnavailable({ client });
         await killProxy(proxyProcess);
-        await new Promise((r) => { setTimeout(r, 1000); });
+        await gatewayUnavailable;
         // Restart proxy on same port
+        const reconnection = waitForReconnection({ client, events, label: 'local' });
         proxyProcess = startProxy(proxyOpts);
         await waitForProxyReady({ port: proxyPort });
         console.log('[local] Proxy restarted');
-        const reconnected = await waitForReconnection({ client, events, label: 'local' });
+        const reconnected = await reconnection;
         console.log('[local] All events:', events);
         if (!reconnected) {
             dumpProxyLogs(firstProxy);