kimaki 0.26.0 → 0.28.0

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);

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

@@ -19,7 +19,7 @@ import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, } from './database.js';
 import { setDataDir } from './config.js';
 import { startDiscordBot } from './discord-bot.js';
-import { chooseLockPort, cleanupTestSessions, initTestGitRepo, waitForFooterMessage, } from './test-utils.js';
+import { chooseLockPort, cleanupTestSessions, initTestGitRepo, getMessageVisibleText, waitForFooterMessage, } from './test-utils.js';
 import { stopOpencodeServer } from './opencode.js';
 import { createDiscordRest } from './discord-urls.js';
 import { store } from './store.js';
@@ -323,12 +323,12 @@ describeIf('gateway-proxy e2e', () => {
         "--- from: user (proxy-tester)
         hello from gateway proxy test
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ gateway-proxy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > *using deterministic-provider/deterministic-v2*
+        > gateway-proxy-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@900000000000000001>"
       `);
         expect(reply).toBeDefined();
-        expect(reply.content.trim().length).toBeGreaterThan(0);
+        expect(getMessageVisibleText(reply).trim().length).toBeGreaterThan(0);
     }, 15_000);
     test('follow-up message in thread gets bot reply', async () => {
         const existingMessages = await discord.thread(firstThreadId).getMessages();
@@ -350,17 +350,17 @@ describeIf('gateway-proxy e2e', () => {
         "--- from: user (proxy-tester)
         hello from gateway proxy test
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ gateway-proxy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > gateway-proxy-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@900000000000000001>
         --- from: user (proxy-tester)
         follow up through proxy
         --- from: assistant (TestBot)
-        ⬥ gateway-proxy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > gateway-proxy-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@900000000000000001>"
       `);
         expect(reply).toBeDefined();
-        expect(reply.content.trim().length).toBeGreaterThan(0);
+        expect(getMessageVisibleText(reply).trim().length).toBeGreaterThan(0);
     }, 15_000);
     // Reconnect test lives in gateway-proxy-reconnect.e2e.test.ts.
     // It was here before but kills the proxy mid-suite, breaking shared
@@ -382,14 +382,14 @@ describeIf('gateway-proxy e2e', () => {
         "--- from: user (proxy-tester)
         hello from gateway proxy test
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ gateway-proxy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > gateway-proxy-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@900000000000000001>
         --- from: user (proxy-tester)
         follow up through proxy
         --- from: assistant (TestBot)
-        ⬥ gateway-proxy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > gateway-proxy-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@900000000000000001>
         --- from: user (proxy-tester)
         !echo proxy-shell-test
         --- from: assistant (TestBot)
@@ -417,10 +417,10 @@ describeIf('gateway-proxy e2e', () => {
         "--- from: user (proxy-tester)
         second message through proxy
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*"
+        > *using deterministic-provider/deterministic-v2*"
       `);
         expect(reply).toBeDefined();
-        expect(reply.content.trim().length).toBeGreaterThan(0);
+        expect(getMessageVisibleText(reply).trim().length).toBeGreaterThan(0);
     }, 15_000);
     test('guild-2 message does not create thread (guild isolation)', async () => {
         await discord.channel(CHANNEL_2_ID).user(TEST_USER_ID).sendMessage({