kimaki 0.28.0 → 0.29.0

package/dist/guild-categories.test.js

@@ -0,0 +1,225 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { afterEach, beforeEach, expect, test } from 'vitest';
+import { ChannelType, Client, Events, GatewayIntentBits } from 'discord.js';
+import { DigitalDiscord } from 'discord-digital-twin/src';
+import { setDataDir } from './config.js';
+import { closeDb } from './db.js';
+import { createDefaultKimakiChannel, createProjectChannels, ensureKimakiCategory, } from './channel-management.js';
+import { getGuildCategories, initDatabase, setChannelDirectory, } from './database.js';
+const guildId = '100000000000000111';
+const otherGuildId = '100000000000000222';
+let directory;
+let discord;
+let client;
+async function startDiscord({ dataDir }) {
+    discord = new DigitalDiscord({
+        dbUrl: `file:${path.join(dataDir, 'discord.db')}`,
+        users: [{ id: '100000000000000555', username: 'server-owner' }],
+        guilds: [
+            { id: guildId, name: 'Studio', ownerId: '100000000000000555' },
+            { id: otherGuildId, name: 'Office', ownerId: '100000000000000555' },
+        ],
+    });
+    await discord.start();
+    client = new Client({
+        intents: [GatewayIntentBits.Guilds],
+        rest: { api: discord.restUrl, version: '10' },
+    });
+    const ready = new Promise((resolve) => client.once(Events.ClientReady, () => resolve()));
+    await client.login(discord.botToken);
+    await ready;
+}
+async function openDataDir() {
+    const root = path.resolve('tmp/guild-categories');
+    fs.mkdirSync(root, { recursive: true });
+    directory = fs.mkdtempSync(path.join(root, 'run-'));
+    setDataDir(directory);
+    await closeDb();
+    await initDatabase();
+}
+beforeEach(async () => {
+    await openDataDir();
+    await startDiscord({ dataDir: directory });
+});
+afterEach(async () => {
+    await client?.destroy();
+    await discord?.stop();
+    await closeDb();
+    fs.rmSync(directory, { recursive: true, force: true });
+});
+function guild() {
+    return client.guilds.cache.get(guildId);
+}
+test('first project creates a Kimaki group and stores its id', async () => {
+    const created = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'web'),
+    });
+    const channel = await guild().channels.fetch(created.textChannelId);
+    expect(channel?.parentId).toBeTruthy();
+    const category = await guild().channels.fetch(channel.parentId);
+    expect(category?.name).toBe('Kimaki');
+    expect(await getGuildCategories(guildId)).toEqual({
+        guild_id: guildId,
+        category_id: category.id,
+        audio_category_id: null,
+    });
+});
+test('renamed group still receives new project channels', async () => {
+    const first = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'web'),
+    });
+    const firstChannel = await guild().channels.fetch(first.textChannelId);
+    const category = await guild().channels.fetch(firstChannel.parentId);
+    await category.setName('laptop');
+    const second = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'api'),
+    });
+    const secondChannel = await guild().channels.fetch(second.textChannelId);
+    expect(secondChannel?.parentId).toBe(firstChannel?.parentId);
+    expect((await guild().channels.fetch(secondChannel.parentId))?.name).toBe('laptop');
+});
+test('a second machine creates its own Kimaki group', async () => {
+    const first = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'web'),
+    });
+    const firstParent = (await guild().channels.fetch(first.textChannelId))
+        ?.parentId;
+    await closeDb();
+    await openDataDir();
+    const second = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'api'),
+    });
+    const secondParent = (await guild().channels.fetch(second.textChannelId))
+        ?.parentId;
+    expect(secondParent).toBeTruthy();
+    expect(secondParent).not.toBe(firstParent);
+    const categories = [...guild().channels.cache.values()].filter((channel) => channel.type === ChannelType.GuildCategory);
+    expect(categories.map((channel) => channel.name).sort()).toEqual([
+        'Kimaki',
+        'Kimaki',
+    ]);
+});
+test('existing project channels adopt their parent without creating a new group', async () => {
+    const category = await guild().channels.create({
+        name: 'studio',
+        type: ChannelType.GuildCategory,
+    });
+    const text = await guild().channels.create({
+        name: 'web',
+        type: ChannelType.GuildText,
+        parent: category,
+    });
+    await setChannelDirectory({
+        channelId: text.id,
+        directory: path.join(directory, 'web'),
+        channelType: 'text',
+        guildId,
+    });
+    const resolved = await ensureKimakiCategory(guild());
+    expect(resolved.id).toBe(category.id);
+    expect(await getGuildCategories(guildId)).toMatchObject({
+        guild_id: guildId,
+        category_id: category.id,
+    });
+    const categoryCount = [...guild().channels.cache.values()].filter((channel) => channel.type === ChannelType.GuildCategory).length;
+    expect(categoryCount).toBe(1);
+});
+test('a second machine gets its own default kimaki channel', async () => {
+    const first = await createDefaultKimakiChannel({
+        guild: guild(),
+        appId: discord.botUserId,
+        isGatewayMode: true,
+    });
+    expect(first).toBeTruthy();
+    await closeDb();
+    await openDataDir();
+    const second = await createDefaultKimakiChannel({
+        guild: guild(),
+        appId: discord.botUserId,
+        isGatewayMode: true,
+    });
+    expect(second).toBeTruthy();
+    expect(second.textChannelId).not.toBe(first.textChannelId);
+    expect(second.textChannel.parentId).not.toBe(first.textChannel.parentId);
+});
+test('legacy rows from another guild do not block adoption', async () => {
+    const otherGuild = client.guilds.cache.get(otherGuildId);
+    const foreignCategory = await otherGuild.channels.create({
+        name: 'foreign',
+        type: ChannelType.GuildCategory,
+    });
+    const foreignChannel = await otherGuild.channels.create({
+        name: 'web',
+        type: ChannelType.GuildText,
+        parent: foreignCategory,
+    });
+    const localCategory = await guild().channels.create({
+        name: 'studio',
+        type: ChannelType.GuildCategory,
+    });
+    const localChannel = await guild().channels.create({
+        name: 'api',
+        type: ChannelType.GuildText,
+        parent: localCategory,
+    });
+    await setChannelDirectory({
+        channelId: foreignChannel.id,
+        directory: path.join(directory, 'foreign'),
+        channelType: 'text',
+    });
+    await setChannelDirectory({
+        channelId: localChannel.id,
+        directory: path.join(directory, 'api'),
+        channelType: 'text',
+    });
+    const resolved = await ensureKimakiCategory(guild());
+    expect(resolved.id).toBe(localCategory.id);
+});
+test('a kimaki-prefixed project channel does not block the default channel', async () => {
+    await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'kimaki-tools'),
+    });
+    const created = await createDefaultKimakiChannel({
+        guild: guild(),
+        appId: discord.botUserId,
+        isGatewayMode: true,
+    });
+    expect(created).toBeTruthy();
+    expect(created.channelName).toBe('kimaki');
+});
+test('concurrent first creates share one group', async () => {
+    const [first, second] = await Promise.all([
+        ensureKimakiCategory(guild()),
+        ensureKimakiCategory(guild()),
+    ]);
+    expect(first.id).toBe(second.id);
+    const categories = [...guild().channels.cache.values()].filter((channel) => channel.type === ChannelType.GuildCategory);
+    expect(categories).toHaveLength(1);
+});
+test('deleted group is replaced and SQLite is updated', async () => {
+    const first = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'web'),
+    });
+    const firstParent = (await guild().channels.fetch(first.textChannelId))
+        ?.parentId;
+    await (await guild().channels.fetch(firstParent)).delete();
+    const second = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'api'),
+    });
+    const secondParent = (await guild().channels.fetch(second.textChannelId))
+        ?.parentId;
+    expect(secondParent).toBeTruthy();
+    expect(secondParent).not.toBe(firstParent);
+    expect(await getGuildCategories(guildId)).toMatchObject({
+        category_id: secondParent,
+    });
+});

package/dist/interaction-handler.js

@@ -28,7 +28,7 @@ import { handleAskQuestionSelectMenu } from './commands/ask-question.js';
 import { handleFileUploadButton, handleFileUploadModalSubmit, } from './commands/file-upload.js';
 import { handleActionButton } from './commands/action-buttons.js';
 import { handleHtmlActionButton } from './html-actions.js';
-import { handleQueueCommand, handleClearQueueCommand, handleQueueCommandCommand, handleQueueCommandAutocomplete, } from './commands/queue.js';
+import { handleQueueCommand, handleClearQueueCommand, handleQueueCommandCommand, handleQueueCommandAutocomplete, handleQueueRemoveButton, QUEUE_REMOVE_CUSTOM_ID_PREFIX, } from './commands/queue.js';
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js';
 import { handleUserCommand } from './commands/user-command.js';
 import { handleVerbosityCommand, handleVerbositySelectMenu, } from './commands/verbosity.js';
@@ -397,6 +397,10 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                         await handleActionButton(interaction);
                         return;
                     }
+                    if (customId.startsWith(QUEUE_REMOVE_CUSTOM_ID_PREFIX)) {
+                        await handleQueueRemoveButton(interaction);
+                        return;
+                    }
                     if (customId.startsWith('html_action:')) {
                         await handleHtmlActionButton(interaction);
                         return;

package/dist/kimaki-opencode-plugin.js

@@ -11,6 +11,7 @@
 // - 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';
@@ -29,3 +30,4 @@ export { injectionGuardInternal as injectionGuard } from 'opencode-injection-gua
 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';

package/dist/kimaki-opencode-plugin.test.js

@@ -1,5 +1,6 @@
 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 = [
@@ -96,3 +97,30 @@ describe('condenseMemoryMd', () => {
     `);
     });
 });
+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/dist/list-channel-threads.js

@@ -0,0 +1,163 @@
+import { ChannelType, Routes } from 'discord.js';
+import * as errore from 'errore';
+import { DiscordApiError } from './errors.js';
+import { isThreadChannelType } from './discord-utils.js';
+export const DISCORD_THREAD_LIST_PAGE_SIZE = 100;
+const ARCHIVED_THREAD_FETCH_LIMIT = 200;
+class DiscordThreadListError extends errore.createTaggedError({
+    name: 'DiscordThreadListError',
+    message: 'Failed to list Discord threads for channel $channelId',
+}) {
+}
+export function parseDiscordThreadPayload({ payload, parentId, guildId, }) {
+    if (!payload.id || !isThreadChannelType(payload.type ?? -1)) {
+        return null;
+    }
+    if (payload.parent_id && payload.parent_id !== parentId) {
+        return null;
+    }
+    const archived = Boolean(payload.thread_metadata?.archived);
+    return {
+        id: payload.id,
+        name: payload.name || payload.id,
+        parentId,
+        guildId: payload.guild_id || guildId,
+        archived,
+        archiveState: archived ? 'archived' : 'active',
+        lastMessageId: payload.last_message_id ?? null,
+    };
+}
+export function mergeDiscordChannelThreads({ threads, }) {
+    const byId = new Map();
+    for (const thread of threads) {
+        byId.set(thread.id, thread);
+    }
+    return [...byId.values()].sort((left, right) => {
+        if (left.archived !== right.archived) {
+            return left.archived ? 1 : -1;
+        }
+        const leftMessage = left.lastMessageId ?? '';
+        const rightMessage = right.lastMessageId ?? '';
+        if (leftMessage !== rightMessage) {
+            return rightMessage.localeCompare(leftMessage);
+        }
+        return left.name.localeCompare(right.name);
+    });
+}
+function parseThreadListPayload({ payload, parentId, guildId, }) {
+    if (!payload || typeof payload !== 'object') {
+        return { threads: [], hasMore: false };
+    }
+    const list = payload;
+    const threads = (list.threads ?? []).flatMap((thread) => {
+        const parsed = parseDiscordThreadPayload({
+            payload: thread,
+            parentId,
+            guildId,
+        });
+        return parsed ? [parsed] : [];
+    });
+    return {
+        threads,
+        hasMore: Boolean(list.has_more),
+    };
+}
+async function fetchDiscordJson({ rest, route, query, }) {
+    const result = await rest
+        .get(route, query ? { query } : undefined)
+        .catch((cause) => {
+        return new DiscordApiError({
+            status: String(Reflect.get(cause, 'status') ?? 'unknown'),
+            body: cause instanceof Error ? cause.message : String(cause),
+            cause,
+        });
+    });
+    return result;
+}
+async function listArchivedPublicThreads({ rest, channelId, guildId, }) {
+    const threads = [];
+    let before;
+    while (threads.length < ARCHIVED_THREAD_FETCH_LIMIT) {
+        const query = new URLSearchParams({
+            limit: String(DISCORD_THREAD_LIST_PAGE_SIZE),
+        });
+        if (before) {
+            query.set('before', before);
+        }
+        const payload = await fetchDiscordJson({
+            rest,
+            route: Routes.channelThreads(channelId, 'public'),
+            query,
+        });
+        if (payload instanceof DiscordApiError) {
+            return payload;
+        }
+        const page = parseThreadListPayload({
+            payload,
+            parentId: channelId,
+            guildId,
+        });
+        threads.push(...page.threads);
+        const lastThread = page.threads.at(-1);
+        if (!page.hasMore || !lastThread) {
+            break;
+        }
+        before = lastThread.id;
+    }
+    return threads;
+}
+export async function listDiscordChannelThreads({ rest, channelId, }) {
+    const channelPayload = await fetchDiscordJson({
+        rest,
+        route: Routes.channel(channelId),
+    });
+    if (channelPayload instanceof DiscordApiError) {
+        return { ok: false, error: channelPayload };
+    }
+    const channel = (channelPayload ?? {});
+    if (channel.type !== ChannelType.GuildText) {
+        return {
+            ok: false,
+            error: new DiscordThreadListError({
+                channelId,
+                cause: new Error('Channel is not a guild text channel'),
+            }),
+        };
+    }
+    const guildId = channel.guild_id;
+    if (!guildId) {
+        return {
+            ok: false,
+            error: new DiscordThreadListError({
+                channelId,
+                cause: new Error('Channel has no guild ID'),
+            }),
+        };
+    }
+    const activePayload = await fetchDiscordJson({
+        rest,
+        route: Routes.guildActiveThreads(guildId),
+    });
+    if (activePayload instanceof DiscordApiError) {
+        return { ok: false, error: activePayload };
+    }
+    const activeThreads = parseThreadListPayload({
+        payload: activePayload,
+        parentId: channelId,
+        guildId,
+    }).threads;
+    const archivedThreads = await listArchivedPublicThreads({
+        rest,
+        channelId,
+        guildId,
+    });
+    if (archivedThreads instanceof DiscordApiError) {
+        return { ok: false, error: archivedThreads };
+    }
+    return {
+        ok: true,
+        threads: mergeDiscordChannelThreads({
+            threads: [...activeThreads, ...archivedThreads],
+        }),
+    };
+}

package/dist/list-channel-threads.test.js

@@ -0,0 +1,80 @@
+import { ChannelType } from 'discord.js';
+import { describe, expect, test } from 'vitest';
+import { mergeDiscordChannelThreads, parseDiscordThreadPayload, } from './list-channel-threads.js';
+describe('list-channel-threads', () => {
+    test('parses public threads and skips other channel types', () => {
+        const parsed = parseDiscordThreadPayload({
+            payload: {
+                id: 'thread-1',
+                name: 'Fix auth timeout',
+                type: ChannelType.PublicThread,
+                parent_id: 'channel-1',
+                guild_id: 'guild-1',
+                last_message_id: 'msg-9',
+                thread_metadata: { archived: false },
+            },
+            parentId: 'channel-1',
+            guildId: 'guild-1',
+        });
+        expect(parsed).toMatchInlineSnapshot(`
+      {
+        "archiveState": "active",
+        "archived": false,
+        "guildId": "guild-1",
+        "id": "thread-1",
+        "lastMessageId": "msg-9",
+        "name": "Fix auth timeout",
+        "parentId": "channel-1",
+      }
+    `);
+        expect(parseDiscordThreadPayload({
+            payload: {
+                id: 'not-a-thread',
+                name: 'website',
+                type: ChannelType.GuildText,
+                parent_id: 'category-1',
+            },
+            parentId: 'channel-1',
+            guildId: 'guild-1',
+        })).toBe(null);
+    });
+    test('keeps active threads first and drops duplicate ids', () => {
+        const merged = mergeDiscordChannelThreads({
+            threads: [
+                {
+                    id: 'thread-old',
+                    name: 'Old work',
+                    parentId: 'channel-1',
+                    guildId: 'guild-1',
+                    archived: true,
+                    archiveState: 'archived',
+                    lastMessageId: '2',
+                },
+                {
+                    id: 'thread-new',
+                    name: 'New work',
+                    parentId: 'channel-1',
+                    guildId: 'guild-1',
+                    archived: false,
+                    archiveState: 'active',
+                    lastMessageId: '1',
+                },
+                {
+                    id: 'thread-new',
+                    name: 'New work duplicate',
+                    parentId: 'channel-1',
+                    guildId: 'guild-1',
+                    archived: false,
+                    archiveState: 'active',
+                    lastMessageId: '9',
+                },
+            ],
+        });
+        expect(merged.map((thread) => thread.id)).toMatchInlineSnapshot(`
+      [
+        "thread-new",
+        "thread-old",
+      ]
+    `);
+    });
+});

package/dist/message-formatting.js

@@ -195,31 +195,22 @@ export function shouldQuoteIntermediateTextPart({ part, isLastInTurn, nextToolNa
     return true;
 }
 export function planAssistantTurnFlush({ parts, mode, throughPartId, }) {
-    const lastText = parts.filter(isNonEmptyTextPart).at(-1);
-    const lastTextIndex = lastText
-        ? parts.findLastIndex((part) => part.id === lastText.id)
-        : -1;
     const throughIndex = throughPartId
         ? parts.findIndex((part) => part.id === throughPartId)
         : -1;
     const sendUntil = (() => {
-        if (mode === 'final')
-            return parts.length;
-        if (mode === 'interactive') {
-            if (throughIndex >= 0)
-                return throughIndex + 1;
-            return parts.length;
-        }
-        if (!lastText)
-            return parts.length;
-        // Hold unfinished last text and anything after it so tool order stays intact.
-        if (!lastText.time?.end)
-            return lastTextIndex;
+        if (mode === 'interactive' && throughIndex >= 0)
+            return throughIndex + 1;
         return parts.length;
     })();
     const sendParts = [];
     const holdParts = [];
     for (const [index, part] of parts.entries()) {
+        // Live tools must not wait for the current text part to end.
+        if (mode === 'progress' && part.type === 'text' && !part.time?.end) {
+            holdParts.push(part);
+            continue;
+        }
         if (index < sendUntil) {
             sendParts.push({
                 part,
@@ -632,6 +623,8 @@ export function formatTaskToolTitle(part) {
 export function formatPart(part, prefix) {
     const pfx = prefix ? `${prefix} ⋅ ` : '';
     if (part.type === 'text') {
+        if (part.synthetic === true)
+            return '';
         const text = part.text?.trim();
         if (!text)
             return '';