kimaki 0.4.2 → 0.4.6

package/dist/escape-backticks.test.js

@@ -0,0 +1,125 @@
+import { test, expect } from 'vitest';
+import { Lexer } from 'marked';
+import { escapeBackticksInCodeBlocks } from './discordBot.js';
+test('escapes single backticks in code blocks', () => {
+    const input = '```js\nconst x = `hello`\n```';
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"\`\`\`js
+const x = \\\`hello\\\`
+\`\`\`
+"
+`);
+});
+test('escapes backticks in code blocks with language', () => {
+    const input = '```typescript\nconst greeting = `Hello, ${name}!`\nconst inline = `test`\n```';
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"\`\`\`typescript
+const greeting = \\\`Hello, \${name}!\\\`
+const inline = \\\`test\\\`
+\`\`\`
+"
+`);
+});
+test('does not escape backticks outside code blocks', () => {
+    const input = 'This is `inline code` and this is a code block:\n```\nconst x = `template`\n```';
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"This is \`inline code\` and this is a code block:
+\`\`\`
+const x = \\\`template\\\`
+\`\`\`
+"
+`);
+});
+test('handles multiple code blocks', () => {
+    const input = `First block:
+\`\`\`js
+const a = \`test\`
+\`\`\`
+
+Some text with \`inline\` code
+
+Second block:
+\`\`\`python
+name = f\`hello {world}\`
+\`\`\``;
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"First block:
+\`\`\`js
+const a = \\\`test\\\`
+\`\`\`
+
+
+Some text with \`inline\` code
+
+Second block:
+\`\`\`python
+name = f\\\`hello {world}\\\`
+\`\`\`
+"
+`);
+});
+test('handles code blocks without language', () => {
+    const input = '```\nconst x = `value`\n```';
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"\`\`\`
+const x = \\\`value\\\`
+\`\`\`
+"
+`);
+});
+test('handles nested backticks in code blocks', () => {
+    const input = '```js\nconst nested = `outer ${`inner`} text`\n```';
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"\`\`\`js
+const nested = \\\`outer \${\\\`inner\\\`} text\\\`
+\`\`\`
+"
+`);
+});
+test('preserves markdown outside code blocks', () => {
+    const input = `# Heading
+
+This is **bold** and *italic* text
+
+\`\`\`js
+const code = \`with template\`
+\`\`\`
+
+- List item 1
+- List item 2`;
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"# Heading
+
+This is **bold** and *italic* text
+
+\`\`\`js
+const code = \\\`with template\\\`
+\`\`\`
+
+
+- List item 1
+- List item 2"
+`);
+});
+test('does not escape code block delimiter backticks', () => {
+    const input = '```js\nconst x = `hello`\n```';
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result.startsWith('```')).toBe(true);
+    expect(result.endsWith('```\n')).toBe(true);
+    expect(result).toContain('\\`hello\\`');
+    expect(result).not.toContain('\\`\\`\\`js');
+    expect(result).not.toContain('\\`\\`\\`\n');
+    expect(result).toMatchInlineSnapshot(`
+"\`\`\`js
+const x = \\\`hello\\\`
+\`\`\`
+"
+`);
+});

package/dist/tools.js

@@ -95,7 +95,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                     .optional()
                     .describe('Optional model to use for this session'),
             }),
-            execute: async ({ message, title, model }) => {
+            execute: async ({ message, title, }) => {
                 if (!message.trim()) {
                     throw new Error(`message must be a non empty string`);
                 }
@@ -114,6 +114,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         path: { id: session.data.id },
                         body: {
                             parts: [{ type: 'text', text: message }],
+                            // model,
                         },
                     })
                         .then(async (response) => {

package/package.json

@@ -2,18 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.2",
-  "scripts": {
-    "dev": "pnpm tsc && tsx --env-file .env src/cli.ts",
-    "prepublishOnly": "pnpm tsc",
-    "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
-    "test": "tsx scripts/test-opencode.ts",
-    "watch": "tsx scripts/watch-session.ts",
-    "test:events": "tsx test-events.ts",
-    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
-    "test:send": "tsx send-test-message.ts",
-    "register-commands": "tsx scripts/register-commands.ts"
-  },
+  "version": "0.4.6",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -35,7 +24,7 @@
     "@discordjs/opus": "^0.10.0",
     "@discordjs/voice": "^0.19.0",
     "@google/genai": "^1.16.0",
-    "@opencode-ai/sdk": "^0.11.0",
+    "@opencode-ai/sdk": "^1.0.115",
     "@purinton/resampler": "^1.0.4",
     "@snazzah/davey": "^0.1.6",
     "ai": "^5.0.29",
@@ -54,5 +43,14 @@
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
     "zod": "^4.0.17"
+  },
+  "scripts": {
+    "dev": "tsx --env-file .env src/cli.ts",
+    "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
+    "watch": "tsx scripts/watch-session.ts",
+    "test:events": "tsx test-events.ts",
+    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
+    "test:send": "tsx send-test-message.ts",
+    "register-commands": "tsx scripts/register-commands.ts"
   }
-}
+}

package/src/cli.ts

@@ -20,6 +20,8 @@ import {
   getDatabase,
   startDiscordBot,
   initializeOpencodeForDirectory,
+  ensureKimakiCategory,
+  createProjectChannels,
   type ChannelWithTags,
 } from './discordBot.js'
 import type { OpencodeClient } from '@opencode-ai/sdk'
@@ -35,13 +37,27 @@ import {
 import path from 'node:path'
 import fs from 'node:fs'
 import { createLogger } from './logger.js'
-import { spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
+import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
 
 const cliLogger = createLogger('CLI')
 const cli = cac('kimaki')
 
 process.title = 'kimaki'
 
+process.on('SIGUSR2', () => {
+  cliLogger.info('Received SIGUSR2, restarting process in 1000ms...')
+  setTimeout(() => {
+    cliLogger.info('Restarting...')
+    spawn(process.argv[0]!, [...process.execArgv, ...process.argv.slice(1)], {
+      stdio: 'inherit',
+      detached: true,
+      cwd: process.cwd(),
+      env: process.env,
+    }).unref()
+    process.exit(0)
+  }, 1000)
+})
+
 const EXIT_NO_RESTART = 64
 
 type Project = {
@@ -97,6 +113,19 @@ async function registerCommands(token: string, appId: string) {
         return option
       })
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('add-project')
+      .setDescription('Create Discord channels for a new OpenCode project')
+      .addStringOption((option) => {
+        option
+          .setName('project')
+          .setDescription('Select an OpenCode project')
+          .setRequired(true)
+          .setAutocomplete(true)
+
+        return option
+      })
+      .toJSON(),
   ]
 
   const rest = new REST().setToken(token)
@@ -117,26 +146,7 @@ async function registerCommands(token: string, appId: string) {
   }
 }
 
-async function ensureKimakiCategory(guild: Guild): Promise<CategoryChannel> {
-  const existingCategory = guild.channels.cache.find(
-    (channel): channel is CategoryChannel => {
-      if (channel.type !== ChannelType.GuildCategory) {
-        return false
-      }
-
-      return channel.name.toLowerCase() === 'kimaki'
-    },
-  )
-
-  if (existingCategory) {
-    return existingCategory
-  }
 
-  return guild.channels.create({
-    name: 'Kimaki',
-    type: ChannelType.GuildCategory,
-  })
-}
 
 async function run({ restart, addChannels }: CliOptions) {
   const forceSetup = Boolean(restart)
@@ -530,43 +540,20 @@ async function run({ restart, addChannels }: CliOptions) {
         const project = projects.find((p) => p.id === projectId)
         if (!project) continue
 
-        const baseName = path.basename(project.worktree)
-        const channelName = `${baseName}`
-          .toLowerCase()
-          .replace(/[^a-z0-9-]/g, '-')
-          .slice(0, 100)
-
         try {
-          const kimakiCategory = await ensureKimakiCategory(targetGuild)
-
-          const textChannel = await targetGuild.channels.create({
-            name: channelName,
-            type: ChannelType.GuildText,
-            parent: kimakiCategory,
-            topic: `<kimaki><directory>${project.worktree}</directory><app>${appId}</app></kimaki>`,
-          })
-
-          const voiceChannel = await targetGuild.channels.create({
-            name: channelName,
-            type: ChannelType.GuildVoice,
-            parent: kimakiCategory,
+          const { textChannelId, channelName } = await createProjectChannels({
+            guild: targetGuild,
+            projectDirectory: project.worktree,
+            appId,
           })
 
-          db.prepare(
-            'INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)',
-          ).run(textChannel.id, project.worktree, 'text')
-
-          db.prepare(
-            'INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)',
-          ).run(voiceChannel.id, project.worktree, 'voice')
-
           createdChannels.push({
-            name: textChannel.name,
-            id: textChannel.id,
+            name: channelName,
+            id: textChannelId,
             guildId: targetGuild.id,
           })
         } catch (error) {
-          cliLogger.error(`Failed to create channels for ${baseName}:`, error)
+          cliLogger.error(`Failed to create channels for ${path.basename(project.worktree)}:`, error)
         }
       }