kimaki 0.4.73 → 0.4.75

package/dist/agent-model.e2e.test.js

@@ -14,7 +14,7 @@ import net from 'node:net';
 import path from 'node:path';
 import url from 'node:url';
 import { describe, beforeAll, afterAll, test, expect, } from 'vitest';
-import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js';
+import { ChannelType, Client, GatewayIntentBits, Partials, REST, Routes, SlashCommandBuilder } from 'discord.js';
 import { DigitalDiscord } from 'discord-digital-twin/src';
 import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provider';
 import { setDataDir } from './config.js';
@@ -23,11 +23,13 @@ import { startDiscordBot } from './discord-bot.js';
 import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, setChannelAgent, setChannelModel, } from './database.js';
 import { getPrisma } from './db.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
-import { initializeOpencodeForDirectory } from './opencode.js';
-import { cleanupOpencodeServers, cleanupTestSessions, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js';
+import { cleanupTestSessions, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import { buildQuickAgentCommandDescription } from './commands/agent.js';
 const TEST_USER_ID = '200000000000000920';
 const TEXT_CHANNEL_ID = '200000000000000921';
 const AGENT_MODEL = 'agent-model-v2';
+const PLAN_AGENT_MODEL = 'plan-model-v2';
 const CHANNEL_MODEL = 'channel-model-v2';
 const DEFAULT_MODEL = 'deterministic-v2';
 const PROVIDER_NAME = 'deterministic-provider';
@@ -200,14 +202,20 @@ describe('agent model resolution', () => {
         // Add extra models to the provider so opencode accepts them
         const providerConfig = opencodeConfig.provider[PROVIDER_NAME];
         providerConfig.models[AGENT_MODEL] = { name: AGENT_MODEL };
+        providerConfig.models[PLAN_AGENT_MODEL] = { name: PLAN_AGENT_MODEL };
         providerConfig.models[CHANNEL_MODEL] = { name: CHANNEL_MODEL };
         fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
-        // Create the agent .md file with custom model
+        // Create agent .md files with custom models
         createAgentFile({
             projectDirectory: directories.projectDirectory,
             agentName: 'test-agent',
             model: `${PROVIDER_NAME}/${AGENT_MODEL}`,
         });
+        createAgentFile({
+            projectDirectory: directories.projectDirectory,
+            agentName: 'plan',
+            model: `${PROVIDER_NAME}/${PLAN_AGENT_MODEL}`,
+        });
         const dbPath = path.join(directories.dataDir, 'discord-sessions.db');
         const hranaResult = await startHranaServer({ dbPath });
         if (hranaResult instanceof Error) {
@@ -228,6 +236,20 @@ describe('agent model resolution', () => {
             appId: discord.botUserId,
             discordClient: botClient,
         });
+        // Register quick agent slash commands so /plan-agent and /test-agent-agent
+        // are resolvable by handleQuickAgentCommand via guild.commands.fetch().
+        const agentCommands = ['test-agent', 'plan'].map((agentName) => {
+            return new SlashCommandBuilder()
+                .setName(`${agentName}-agent`)
+                .setDescription(buildQuickAgentCommandDescription({
+                agentName,
+                description: `Switch to ${agentName} agent`,
+            }))
+                .setDMPermission(false)
+                .toJSON();
+        });
+        const rest = new REST({ version: '10', api: discord.restUrl }).setToken(discord.botToken);
+        await rest.put(Routes.applicationGuildCommands(discord.botUserId, discord.guildId), { body: agentCommands });
         // Pre-warm the opencode server so agent discovery happens
         const warmup = await initializeOpencodeForDirectory(directories.projectDirectory);
         if (warmup instanceof Error) {
@@ -244,7 +266,7 @@ describe('agent model resolution', () => {
         if (botClient) {
             botClient.destroy();
         }
-        await cleanupOpencodeServers();
+        await stopOpencodeServer();
         await Promise.all([
             closeDatabase().catch(() => {
                 return;
@@ -449,4 +471,224 @@ describe('agent model resolution', () => {
         expect(footerMessage.content).toContain(CHANNEL_MODEL);
         expect(footerMessage.content).not.toContain(DEFAULT_MODEL);
     }, 15_000);
+    test('changing channel agent via /plan-agent does not affect existing thread model', async () => {
+        // 1. Set channel agent to test-agent (uses AGENT_MODEL)
+        await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
+        // 2. Send a message to create a thread
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: first-thread-msg',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: first-thread-msg';
+            },
+        });
+        // Wait for footer — proves first run completed with test-agent's model
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const firstMessages = await discord.thread(thread.id).getMessages();
+        const firstFooter = firstMessages.find((m) => {
+            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
+        });
+        expect(firstFooter).toBeDefined();
+        // Verify the first run used test-agent's model
+        expect(firstFooter.content).toContain(AGENT_MODEL);
+        // 3. Switch channel agent to plan via /plan-agent in the CHANNEL
+        const { id: interactionId } = await discord
+            .channel(TEXT_CHANNEL_ID)
+            .user(TEST_USER_ID)
+            .runSlashCommand({ name: 'plan-agent' });
+        await discord
+            .channel(TEXT_CHANNEL_ID)
+            .waitForInteractionAck({ interactionId, timeout: 4_000 });
+        // 4. Send a second message in the EXISTING thread
+        const th = discord.thread(thread.id);
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: second-thread-msg',
+        });
+        // Wait for second footer (anchor on the user message, not bot reply)
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'second-thread-msg',
+            afterAuthorId: TEST_USER_ID,
+        });
+        expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: first-thread-msg
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        --- from: user (agent-model-tester)
+        Reply with exactly: second-thread-msg
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
+      `);
+        const secondMessages = await discord.thread(thread.id).getMessages();
+        const secondFooter = [...secondMessages]
+            .reverse()
+            .find((m) => {
+            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
+        });
+        expect(secondFooter).toBeDefined();
+        // The existing thread should still use test-agent's model (AGENT_MODEL),
+        // NOT plan agent's model (PLAN_AGENT_MODEL)
+        expect(secondFooter.content).toContain(AGENT_MODEL);
+        expect(secondFooter.content).not.toContain(PLAN_AGENT_MODEL);
+    }, 20_000);
+    test('thread created with no agent keeps default model after channel agent is set', async () => {
+        // Clear any channel agent — thread starts with default (no agent)
+        const prisma = await getPrisma();
+        await prisma.channel_agents.deleteMany({
+            where: { channel_id: TEXT_CHANNEL_ID },
+        });
+        // Also clear channel model so we get the pure default
+        await prisma.channel_models.deleteMany({
+            where: { channel_id: TEXT_CHANNEL_ID },
+        });
+        // 1. Send a message to create a thread (no channel agent set)
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: default-thread-msg',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: default-thread-msg';
+            },
+        });
+        // Wait for footer — should show the default model
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const firstMessages = await discord.thread(thread.id).getMessages();
+        const firstFooter = firstMessages.find((m) => {
+            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
+        });
+        expect(firstFooter).toBeDefined();
+        // First run uses the default model (no agent set)
+        expect(firstFooter.content).toContain(DEFAULT_MODEL);
+        expect(firstFooter.content).not.toContain(AGENT_MODEL);
+        // 2. Set channel agent to test-agent via /test-agent-agent in the CHANNEL
+        const { id: interactionId } = await discord
+            .channel(TEXT_CHANNEL_ID)
+            .user(TEST_USER_ID)
+            .runSlashCommand({ name: 'test-agent-agent' });
+        await discord
+            .channel(TEXT_CHANNEL_ID)
+            .waitForInteractionAck({ interactionId, timeout: 4_000 });
+        // 3. Send a second message in the EXISTING thread
+        await discord
+            .thread(thread.id)
+            .user(TEST_USER_ID)
+            .sendMessage({
+            content: 'Reply with exactly: default-second-msg',
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'default-second-msg',
+            afterAuthorId: TEST_USER_ID,
+        });
+        expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: default-thread-msg
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        --- from: user (agent-model-tester)
+        Reply with exactly: default-second-msg
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `);
+        const secondMessages = await discord.thread(thread.id).getMessages();
+        const secondFooter = [...secondMessages]
+            .reverse()
+            .find((m) => {
+            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
+        });
+        expect(secondFooter).toBeDefined();
+        // The existing thread should still use the DEFAULT model,
+        // NOT the test-agent's model (AGENT_MODEL)
+        expect(secondFooter.content).toContain(DEFAULT_MODEL);
+        expect(secondFooter.content).not.toContain(AGENT_MODEL);
+    }, 20_000);
+    test('/plan-agent inside a thread switches the model for that thread', async () => {
+        // 1. Start with test-agent on the channel
+        await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
+        // 2. Create a thread — first run uses test-agent's model
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: switch-in-thread-msg',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: switch-in-thread-msg';
+            },
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const firstFooter = (await discord.thread(thread.id).getMessages()).find((m) => {
+            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
+        });
+        expect(firstFooter).toBeDefined();
+        expect(firstFooter.content).toContain(AGENT_MODEL);
+        // 3. Run /plan-agent INSIDE the thread
+        const th = discord.thread(thread.id);
+        const { id: interactionId } = await th
+            .user(TEST_USER_ID)
+            .runSlashCommand({ name: 'plan-agent' });
+        await th.waitForInteractionAck({ interactionId, timeout: 4_000 });
+        // 4. Send a second message in the same thread
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: after-switch-msg',
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'after-switch-msg',
+            afterAuthorId: TEST_USER_ID,
+        });
+        expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: switch-in-thread-msg
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        Switched to **plan** agent for this session next messages (was **test-agent**)
+        --- from: user (agent-model-tester)
+        Reply with exactly: after-switch-msg
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
+      `);
+        const secondFooter = [...(await discord.thread(thread.id).getMessages())]
+            .reverse()
+            .find((m) => {
+            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
+        });
+        expect(secondFooter).toBeDefined();
+        // After /plan-agent in the thread, model should switch to plan's model
+        expect(secondFooter.content).toContain(PLAN_AGENT_MODEL);
+        expect(secondFooter.content).not.toContain(AGENT_MODEL);
+    }, 20_000);
 });

package/dist/channel-management.js

@@ -2,8 +2,13 @@
 // Creates and manages Kimaki project channels (text + voice pairs),
 // extracts channel metadata from topic tags, and ensures category structure.
 import { ChannelType, } from 'discord.js';
+import fs from 'node:fs';
 import path from 'node:path';
-import { getChannelDirectory, setChannelDirectory } from './database.js';
+import { getChannelDirectory, setChannelDirectory, findChannelsByDirectory, } from './database.js';
+import { getProjectsDir } from './config.js';
+import { execAsync } from './worktrees.js';
+import { createLogger, LogPrefix } from './logger.js';
+const logger = createLogger(LogPrefix.CHANNEL);
 export async function ensureKimakiCategory(guild, botName) {
     // Skip appending bot name if it's already "kimaki" to avoid "Kimaki kimaki"
     const isKimakiBot = botName?.toLowerCase() === 'kimaki';
@@ -96,3 +101,127 @@ export async function getChannelsWithDescriptions(guild) {
     }
     return channels;
 }
+const DEFAULT_GITIGNORE = `node_modules/
+dist/
+.env
+.env.*
+!.env.example
+.DS_Store
+tmp/
+*.log
+__pycache__/
+*.pyc
+.venv/
+*.egg-info/
+`;
+const DEFAULT_CHANNEL_TOPIC = 'General channel for misc tasks with Kimaki. Not connected to a specific OpenCode project or repository.';
+/**
+ * Create (or find) the default "kimaki" channel for general-purpose tasks.
+ * Channel name is "kimaki-{botName}" for self-hosted bots, "kimaki" for gateway.
+ * Directory is ~/.kimaki/projects/kimaki, git-initialized with a .gitignore.
+ *
+ * Idempotency: checks the database for an existing channel mapped to the
+ * kimaki projects directory. Also scans guild channels by name+category
+ * as a fallback for channels created before DB mapping existed.
+ */
+export async function createDefaultKimakiChannel({ guild, botName, appId, isGatewayMode, }) {
+    const projectDirectory = path.join(getProjectsDir(), 'kimaki');
+    // Ensure the default kimaki project directory exists before any DB mapping
+    // restoration or git setup. Custom data dirs may not have <dataDir>/projects
+    // created yet, and later writes assume the full path is present.
+    if (!fs.existsSync(projectDirectory)) {
+        fs.mkdirSync(projectDirectory, { recursive: true });
+        logger.log(`Created default kimaki directory: ${projectDirectory}`);
+    }
+    // Hydrate guild channels from API so the cache scan is complete
+    try {
+        await guild.channels.fetch();
+    }
+    catch (error) {
+        logger.warn(`Could not fetch guild channels for ${guild.name}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // 1. Check database for existing channel mapped to this directory.
+    // Check ALL mappings (not just the first) since the same directory could
+    // have stale rows from deleted channels or other guilds.
+    const existingMappings = await findChannelsByDirectory({
+        directory: projectDirectory,
+        channelType: 'text',
+    });
+    const mappedChannelInGuild = existingMappings
+        .map((row) => guild.channels.cache.get(row.channel_id))
+        .find((ch) => ch?.type === ChannelType.GuildText);
+    if (mappedChannelInGuild) {
+        logger.log(`Default kimaki channel already exists: ${mappedChannelInGuild.id}`);
+        return null;
+    }
+    // 2. Fallback: detect existing channel by name+category
+    const kimakiCategory = await ensureKimakiCategory(guild, botName);
+    const existingByName = guild.channels.cache.find((ch) => {
+        if (ch.type !== ChannelType.GuildText) {
+            return false;
+        }
+        if (ch.parentId !== kimakiCategory.id) {
+            return false;
+        }
+        return ch.name === 'kimaki' || ch.name.startsWith('kimaki-');
+    });
+    if (existingByName) {
+        logger.log(`Found existing default kimaki channel by name: ${existingByName.id}, restoring DB mapping`);
+        await setChannelDirectory({
+            channelId: existingByName.id,
+            directory: projectDirectory,
+            channelType: 'text',
+            skipIfExists: true,
+        });
+        return null;
+    }
+    // Git init — gracefully skip if git is not installed
+    const gitDir = path.join(projectDirectory, '.git');
+    if (!fs.existsSync(gitDir)) {
+        try {
+            await execAsync('git init', { cwd: projectDirectory, timeout: 10_000 });
+            logger.log(`Initialized git in: ${projectDirectory}`);
+        }
+        catch (error) {
+            logger.warn(`Could not initialize git in ${projectDirectory}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Write .gitignore if it doesn't exist
+    const gitignorePath = path.join(projectDirectory, '.gitignore');
+    if (!fs.existsSync(gitignorePath)) {
+        fs.writeFileSync(gitignorePath, DEFAULT_GITIGNORE);
+    }
+    // Channel name: "kimaki-{botName}" for self-hosted, "kimaki" for gateway
+    const channelName = (() => {
+        if (isGatewayMode || !botName) {
+            return 'kimaki';
+        }
+        const sanitized = botName
+            .toLowerCase()
+            .replace(/[^a-z0-9-]/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+        if (!sanitized || sanitized === 'kimaki') {
+            return 'kimaki';
+        }
+        return `kimaki-${sanitized}`.slice(0, 100);
+    })();
+    const textChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildText,
+        parent: kimakiCategory,
+        topic: DEFAULT_CHANNEL_TOPIC,
+    });
+    await setChannelDirectory({
+        channelId: textChannel.id,
+        directory: projectDirectory,
+        channelType: 'text',
+    });
+    logger.log(`Created default kimaki channel: #${channelName} (${textChannel.id})`);
+    return {
+        textChannel,
+        textChannelId: textChannel.id,
+        channelName,
+        projectDirectory,
+    };
+}