shuvmaki 0.4.26

package/dist/commands/user-command.js

@@ -0,0 +1,145 @@
+// User-defined OpenCode command handler.
+// Handles slash commands that map to user-configured commands in opencode.json.
+import { ChannelType } from 'discord.js';
+import { extractTagsArrays } from '../xml.js';
+import { handleOpencodeSession } from '../session-handler.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+import { getDatabase } from '../database.js';
+import fs from 'node:fs';
+const userCommandLogger = createLogger('USER_CMD');
+export const handleUserCommand = async ({ command, appId, }) => {
+    const discordCommandName = command.commandName;
+    // Strip the -cmd suffix to get the actual OpenCode command name
+    const commandName = discordCommandName.replace(/-cmd$/, '');
+    const args = command.options.getString('arguments') || '';
+    userCommandLogger.log(`Executing /${commandName} (from /${discordCommandName}) with args: ${args}`);
+    const channel = command.channel;
+    userCommandLogger.log(`Channel info: type=${channel?.type}, id=${channel?.id}, isNull=${channel === null}`);
+    const isThread = channel && [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    const isTextChannel = channel?.type === ChannelType.GuildText;
+    if (!channel || (!isTextChannel && !isThread)) {
+        await command.reply({
+            content: 'This command can only be used in text channels or threads',
+            ephemeral: true,
+        });
+        return;
+    }
+    let projectDirectory;
+    let channelAppId;
+    let textChannel = null;
+    let thread = null;
+    if (isThread) {
+        // Running in an existing thread - get project directory from parent channel
+        thread = channel;
+        textChannel = thread.parent;
+        // Verify this thread has an existing session
+        const row = getDatabase()
+            .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+            .get(thread.id);
+        if (!row) {
+            await command.reply({
+                content: 'This thread does not have an active session. Use this command in a project channel to create a new thread.',
+                ephemeral: true,
+            });
+            return;
+        }
+        if (textChannel?.topic) {
+            const extracted = extractTagsArrays({
+                xml: textChannel.topic,
+                tags: ['kimaki.directory', 'kimaki.app'],
+            });
+            projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+            channelAppId = extracted['kimaki.app']?.[0]?.trim();
+        }
+    }
+    else {
+        // Running in a text channel - will create a new thread
+        textChannel = channel;
+        if (textChannel.topic) {
+            const extracted = extractTagsArrays({
+                xml: textChannel.topic,
+                tags: ['kimaki.directory', 'kimaki.app'],
+            });
+            projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+            channelAppId = extracted['kimaki.app']?.[0]?.trim();
+        }
+    }
+    if (channelAppId && channelAppId !== appId) {
+        await command.reply({
+            content: 'This channel is not configured for this bot',
+            ephemeral: true,
+        });
+        return;
+    }
+    if (!projectDirectory) {
+        await command.reply({
+            content: 'This channel is not configured with a project directory',
+            ephemeral: true,
+        });
+        return;
+    }
+    if (!fs.existsSync(projectDirectory)) {
+        await command.reply({
+            content: `Directory does not exist: ${projectDirectory}`,
+            ephemeral: true,
+        });
+        return;
+    }
+    await command.deferReply({ ephemeral: false });
+    try {
+        // Use the dedicated session.command API instead of formatting as text prompt
+        const commandPayload = { name: commandName, arguments: args };
+        if (isThread && thread) {
+            // Running in existing thread - just send the command
+            await command.editReply(`Running /${commandName}...`);
+            await handleOpencodeSession({
+                prompt: '', // Not used when command is set
+                thread,
+                projectDirectory,
+                channelId: textChannel?.id,
+                command: commandPayload,
+            });
+        }
+        else if (textChannel) {
+            // Running in text channel - create a new thread
+            const starterMessage = await textChannel.send({
+                content: `**/${commandName}**${args ? ` ${args.slice(0, 200)}${args.length > 200 ? '…' : ''}` : ''}`,
+                flags: SILENT_MESSAGE_FLAGS,
+            });
+            const threadName = `/${commandName} ${args.slice(0, 80)}${args.length > 80 ? '…' : ''}`;
+            const newThread = await starterMessage.startThread({
+                name: threadName.slice(0, 100),
+                autoArchiveDuration: 1440,
+                reason: `OpenCode command: ${commandName}`,
+            });
+            await command.editReply(`Started /${commandName} in ${newThread.toString()}`);
+            await handleOpencodeSession({
+                prompt: '', // Not used when command is set
+                thread: newThread,
+                projectDirectory,
+                channelId: textChannel.id,
+                command: commandPayload,
+            });
+        }
+    }
+    catch (error) {
+        userCommandLogger.error(`Error executing /${commandName}:`, error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (command.deferred) {
+            await command.editReply({
+                content: `Failed to execute /${commandName}: ${errorMessage}`,
+            });
+        }
+        else {
+            await command.reply({
+                content: `Failed to execute /${commandName}: ${errorMessage}`,
+                ephemeral: true,
+            });
+        }
+    }
+};

package/dist/database.js

@@ -0,0 +1,184 @@
+// SQLite database manager for persistent bot state.
+// Stores thread-session mappings, bot tokens, channel directories,
+// API keys, and model preferences in ~/.kimaki/discord-sessions.db.
+import Database from 'better-sqlite3';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createLogger } from './logger.js';
+const dbLogger = createLogger('DB');
+let db = null;
+export function getDatabase() {
+    if (!db) {
+        const kimakiDir = path.join(os.homedir(), '.kimaki');
+        try {
+            fs.mkdirSync(kimakiDir, { recursive: true });
+        }
+        catch (error) {
+            dbLogger.error('Failed to create ~/.kimaki directory:', error);
+        }
+        const dbPath = path.join(kimakiDir, 'discord-sessions.db');
+        dbLogger.log(`Opening database at: ${dbPath}`);
+        db = new Database(dbPath);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS thread_sessions (
+        thread_id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS part_messages (
+        part_id TEXT PRIMARY KEY,
+        message_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS bot_tokens (
+        app_id TEXT PRIMARY KEY,
+        token TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS channel_directories (
+        channel_id TEXT PRIMARY KEY,
+        directory TEXT NOT NULL,
+        channel_type TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS bot_api_keys (
+        app_id TEXT PRIMARY KEY,
+        gemini_api_key TEXT,
+        xai_api_key TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        runModelMigrations(db);
+    }
+    return db;
+}
+/**
+ * Run migrations for model preferences tables.
+ * Called on startup and can be called on-demand.
+ */
+export function runModelMigrations(database) {
+    const targetDb = database || getDatabase();
+    targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_models (
+      channel_id TEXT PRIMARY KEY,
+      model_id TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS session_models (
+      session_id TEXT PRIMARY KEY,
+      model_id TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_agents (
+      channel_id TEXT PRIMARY KEY,
+      agent_name TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS session_agents (
+      session_id TEXT PRIMARY KEY,
+      agent_name TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    dbLogger.log('Model preferences migrations complete');
+}
+/**
+ * Get the model preference for a channel.
+ * @returns Model ID in format "provider_id/model_id" or undefined
+ */
+export function getChannelModel(channelId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT model_id FROM channel_models WHERE channel_id = ?')
+        .get(channelId);
+    return row?.model_id;
+}
+/**
+ * Set the model preference for a channel.
+ * @param modelId Model ID in format "provider_id/model_id"
+ */
+export function setChannelModel(channelId, modelId) {
+    const db = getDatabase();
+    db.prepare(`INSERT INTO channel_models (channel_id, model_id, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET model_id = ?, updated_at = CURRENT_TIMESTAMP`).run(channelId, modelId, modelId);
+}
+/**
+ * Get the model preference for a session.
+ * @returns Model ID in format "provider_id/model_id" or undefined
+ */
+export function getSessionModel(sessionId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT model_id FROM session_models WHERE session_id = ?')
+        .get(sessionId);
+    return row?.model_id;
+}
+/**
+ * Set the model preference for a session.
+ * @param modelId Model ID in format "provider_id/model_id"
+ */
+export function setSessionModel(sessionId, modelId) {
+    const db = getDatabase();
+    db.prepare(`INSERT OR REPLACE INTO session_models (session_id, model_id) VALUES (?, ?)`).run(sessionId, modelId);
+}
+/**
+ * Get the agent preference for a channel.
+ */
+export function getChannelAgent(channelId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT agent_name FROM channel_agents WHERE channel_id = ?')
+        .get(channelId);
+    return row?.agent_name;
+}
+/**
+ * Set the agent preference for a channel.
+ */
+export function setChannelAgent(channelId, agentName) {
+    const db = getDatabase();
+    db.prepare(`INSERT INTO channel_agents (channel_id, agent_name, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET agent_name = ?, updated_at = CURRENT_TIMESTAMP`).run(channelId, agentName, agentName);
+}
+/**
+ * Get the agent preference for a session.
+ */
+export function getSessionAgent(sessionId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT agent_name FROM session_agents WHERE session_id = ?')
+        .get(sessionId);
+    return row?.agent_name;
+}
+/**
+ * Set the agent preference for a session.
+ */
+export function setSessionAgent(sessionId, agentName) {
+    const db = getDatabase();
+    db.prepare(`INSERT OR REPLACE INTO session_agents (session_id, agent_name) VALUES (?, ?)`).run(sessionId, agentName);
+}
+export function closeDatabase() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}