shuvmaki 0.4.26

package/src/commands/create-new-project.ts

@@ -0,0 +1,111 @@
+// /create-new-project command - Create a new project folder, initialize git, and start a session.
+
+import { ChannelType, type TextChannel } from 'discord.js'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import type { CommandContext } from './types.js'
+import { createProjectChannels } from '../channel-management.js'
+import { handleOpencodeSession } from '../session-handler.js'
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('CREATE-NEW-PROJECT')
+
+export async function handleCreateNewProjectCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  await command.deferReply({ ephemeral: false })
+
+  const projectName = command.options.getString('name', true)
+  const guild = command.guild
+  const channel = command.channel
+
+  if (!guild) {
+    await command.editReply('This command can only be used in a guild')
+    return
+  }
+
+  if (!channel || channel.type !== ChannelType.GuildText) {
+    await command.editReply('This command can only be used in a text channel')
+    return
+  }
+
+  const sanitizedName = projectName
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 100)
+
+  if (!sanitizedName) {
+    await command.editReply('Invalid project name')
+    return
+  }
+
+  const kimakiDir = path.join(os.homedir(), 'kimaki')
+  const projectDirectory = path.join(kimakiDir, sanitizedName)
+
+  try {
+    if (!fs.existsSync(kimakiDir)) {
+      fs.mkdirSync(kimakiDir, { recursive: true })
+      logger.log(`Created kimaki directory: ${kimakiDir}`)
+    }
+
+    if (fs.existsSync(projectDirectory)) {
+      await command.editReply(
+        `Project directory already exists: ${projectDirectory}`,
+      )
+      return
+    }
+
+    fs.mkdirSync(projectDirectory, { recursive: true })
+    logger.log(`Created project directory: ${projectDirectory}`)
+
+    const { execSync } = await import('node:child_process')
+    execSync('git init', { cwd: projectDirectory, stdio: 'pipe' })
+    logger.log(`Initialized git in: ${projectDirectory}`)
+
+    const { textChannelId, voiceChannelId, channelName } =
+      await createProjectChannels({
+        guild,
+        projectDirectory,
+        appId,
+      })
+
+    const textChannel = (await guild.channels.fetch(
+      textChannelId,
+    )) as TextChannel
+
+    await command.editReply(
+      `✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n\n_Starting session..._`,
+    )
+
+    const starterMessage = await textChannel.send({
+      content: `🚀 **New project initialized**\n📁 \`${projectDirectory}\``,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+
+    const thread = await starterMessage.startThread({
+      name: `Init: ${sanitizedName}`,
+      autoArchiveDuration: 1440,
+      reason: 'New project session',
+    })
+
+    await handleOpencodeSession({
+      prompt:
+        'The project was just initialized. Say hi and ask what the user wants to build.',
+      thread,
+      projectDirectory,
+      channelId: textChannel.id,
+    })
+
+    logger.log(`Created new project ${channelName} at ${projectDirectory}`)
+  } catch (error) {
+    logger.error('[CREATE-NEW-PROJECT] Error:', error)
+    await command.editReply(
+      `Failed to create new project: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}

package/src/commands/fork.ts

@@ -0,0 +1,257 @@
+// /fork command - Fork the session from a past user message.
+
+import {
+  ChatInputCommandInteraction,
+  StringSelectMenuInteraction,
+  StringSelectMenuBuilder,
+  ActionRowBuilder,
+  ChannelType,
+  ThreadAutoArchiveDuration,
+  type ThreadChannel,
+} from 'discord.js'
+import { getDatabase } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from '../discord-utils.js'
+import { collectLastAssistantParts } from '../message-formatting.js'
+import { createLogger } from '../logger.js'
+
+const sessionLogger = createLogger('SESSION')
+const forkLogger = createLogger('FORK')
+
+export async function handleForkCommand(interaction: ChatInputCommandInteraction): Promise<void> {
+  const channel = interaction.channel
+
+  if (!channel) {
+    await interaction.reply({
+      content: 'This command can only be used in a channel',
+      ephemeral: true,
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  if (!isThread) {
+    await interaction.reply({
+      content: 'This command can only be used in a thread with an active session',
+      ephemeral: true,
+    })
+    return
+  }
+
+  const textChannel = await resolveTextChannel(channel as ThreadChannel)
+  const { projectDirectory: directory } = getKimakiMetadata(textChannel)
+
+  if (!directory) {
+    await interaction.reply({
+      content: 'Could not determine project directory for this channel',
+      ephemeral: true,
+    })
+    return
+  }
+
+  const row = getDatabase()
+    .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+    .get(channel.id) as { session_id: string } | undefined
+
+  if (!row?.session_id) {
+    await interaction.reply({
+      content: 'No active session in this thread',
+      ephemeral: true,
+    })
+    return
+  }
+
+  // Defer reply before API calls to avoid 3-second timeout
+  await interaction.deferReply({ ephemeral: true })
+
+  const sessionId = row.session_id
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(directory)
+
+    const messagesResponse = await getClient().session.messages({
+      path: { id: sessionId },
+    })
+
+    if (!messagesResponse.data) {
+      await interaction.editReply({
+        content: 'Failed to fetch session messages',
+      })
+      return
+    }
+
+    const userMessages = messagesResponse.data.filter(
+      (m) => m.info.role === 'user'
+    )
+
+    if (userMessages.length === 0) {
+      await interaction.editReply({
+        content: 'No user messages found in this session',
+      })
+      return
+    }
+
+    const recentMessages = userMessages.slice(-25)
+
+    const options = recentMessages.map((m, index) => {
+      const textPart = m.parts.find((p) => p.type === 'text') as { type: 'text'; text: string } | undefined
+      const preview = textPart?.text?.slice(0, 80) || '(no text)'
+      const label = `${index + 1}. ${preview}${preview.length >= 80 ? '...' : ''}`
+
+      return {
+        label: label.slice(0, 100),
+        value: m.info.id,
+        description: new Date(m.info.time.created).toLocaleString().slice(0, 50),
+      }
+    })
+
+    const encodedDir = Buffer.from(directory).toString('base64')
+
+    const selectMenu = new StringSelectMenuBuilder()
+      .setCustomId(`fork_select:${sessionId}:${encodedDir}`)
+      .setPlaceholder('Select a message to fork from')
+      .addOptions(options)
+
+    const actionRow = new ActionRowBuilder<StringSelectMenuBuilder>()
+      .addComponents(selectMenu)
+
+    await interaction.editReply({
+      content: '**Fork Session**\nSelect the user message to fork from. The forked session will continue as if you had not sent that message:',
+      components: [actionRow],
+    })
+  } catch (error) {
+    forkLogger.error('Error loading messages:', error)
+    await interaction.editReply({
+      content: `Failed to load messages: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+  }
+}
+
+export async function handleForkSelectMenu(interaction: StringSelectMenuInteraction): Promise<void> {
+  const customId = interaction.customId
+
+  if (!customId.startsWith('fork_select:')) {
+    return
+  }
+
+  const [, sessionId, encodedDir] = customId.split(':')
+  if (!sessionId || !encodedDir) {
+    await interaction.reply({
+      content: 'Invalid selection data',
+      ephemeral: true,
+    })
+    return
+  }
+
+  const directory = Buffer.from(encodedDir, 'base64').toString('utf-8')
+  const selectedMessageId = interaction.values[0]
+
+  if (!selectedMessageId) {
+    await interaction.reply({
+      content: 'No message selected',
+      ephemeral: true,
+    })
+    return
+  }
+
+  await interaction.deferReply({ ephemeral: false })
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(directory)
+
+    const forkResponse = await getClient().session.fork({
+      path: { id: sessionId },
+      body: { messageID: selectedMessageId },
+    })
+
+    if (!forkResponse.data) {
+      await interaction.editReply('Failed to fork session')
+      return
+    }
+
+    const forkedSession = forkResponse.data
+    const parentChannel = interaction.channel
+
+    if (!parentChannel || ![
+      ChannelType.PublicThread,
+      ChannelType.PrivateThread,
+      ChannelType.AnnouncementThread,
+    ].includes(parentChannel.type)) {
+      await interaction.editReply('Could not access parent channel')
+      return
+    }
+
+    const textChannel = await resolveTextChannel(parentChannel as ThreadChannel)
+
+    if (!textChannel) {
+      await interaction.editReply('Could not resolve parent text channel')
+      return
+    }
+
+    const thread = await textChannel.threads.create({
+      name: `Fork: ${forkedSession.title}`.slice(0, 100),
+      autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+      reason: `Forked from session ${sessionId}`,
+    })
+
+    getDatabase()
+      .prepare(
+        'INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)'
+      )
+      .run(thread.id, forkedSession.id)
+
+    sessionLogger.log(
+      `Created forked session ${forkedSession.id} in thread ${thread.id}`
+    )
+
+    await sendThreadMessage(
+      thread,
+      `**Forked session created!**\nFrom: \`${sessionId}\`\nNew session: \`${forkedSession.id}\``,
+    )
+
+    // Fetch and display the last assistant messages from the forked session
+    const messagesResponse = await getClient().session.messages({
+      path: { id: forkedSession.id },
+    })
+
+    if (messagesResponse.data) {
+      const { partIds, content } = collectLastAssistantParts({
+        messages: messagesResponse.data,
+      })
+
+      if (content.trim()) {
+        const discordMessage = await sendThreadMessage(thread, content)
+
+        // Store part-message mappings for future reference
+        const stmt = getDatabase().prepare(
+          'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
+        )
+        const transaction = getDatabase().transaction((ids: string[]) => {
+          for (const partId of ids) {
+            stmt.run(partId, discordMessage.id, thread.id)
+          }
+        })
+        transaction(partIds)
+      }
+    }
+
+    await sendThreadMessage(
+      thread,
+      `You can now continue the conversation from this point.`,
+    )
+
+    await interaction.editReply(
+      `Session forked! Continue in ${thread.toString()}`
+    )
+  } catch (error) {
+    forkLogger.error('Error forking session:', error)
+    await interaction.editReply(
+      `Failed to fork session: ${error instanceof Error ? error.message : 'Unknown error'}`
+    )
+  }
+}