@brianli/kimaki 0.4.72-brianli.1

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

@@ -0,0 +1,179 @@
+// /create-new-project command - Create a new project folder, initialize git, and start a session.
+// Also exports createNewProject() for reuse during onboarding (welcome channel creation).
+
+import { ChannelType, type Guild, type TextChannel } from 'discord.js'
+import fs from 'node:fs'
+import path from 'node:path'
+import { execSync } from 'node:child_process'
+import type { CommandContext } from './types.js'
+import { getProjectsDir } from '../config.js'
+import { createProjectChannels } from '../channel-management.js'
+import { handleOpencodeSession } from '../session-handler.js'
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const logger = createLogger(LogPrefix.CREATE_PROJECT)
+
+/**
+ * Core project creation logic: creates directory, inits git, creates Discord channels.
+ * Reused by the slash command handler and by onboarding (welcome channel).
+ * Returns null if the project directory already exists.
+ */
+export async function createNewProject({
+  guild,
+  projectName,
+  appId,
+  botName,
+}: {
+  guild: Guild
+  projectName: string
+  appId: string
+  botName?: string
+}): Promise<{
+  textChannelId: string
+  voiceChannelId: string | null
+  channelName: string
+  projectDirectory: string
+  sanitizedName: string
+} | null> {
+  const sanitizedName = projectName
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 100)
+
+  if (!sanitizedName) {
+    return null
+  }
+
+  const projectsDir = getProjectsDir()
+  const projectDirectory = path.join(projectsDir, sanitizedName)
+
+  if (!fs.existsSync(projectsDir)) {
+    fs.mkdirSync(projectsDir, { recursive: true })
+    logger.log(`Created projects directory: ${projectsDir}`)
+  }
+
+  if (fs.existsSync(projectDirectory)) {
+    return null
+  }
+
+  fs.mkdirSync(projectDirectory, { recursive: true })
+  logger.log(`Created project directory: ${projectDirectory}`)
+
+  execSync('git init', { cwd: projectDirectory, stdio: 'pipe' })
+  logger.log(`Initialized git in: ${projectDirectory}`)
+
+  const { textChannelId, voiceChannelId, channelName } =
+    await createProjectChannels({
+      guild,
+      projectDirectory,
+      appId,
+      botName,
+    })
+
+  return {
+    textChannelId,
+    voiceChannelId,
+    channelName,
+    projectDirectory,
+    sanitizedName,
+  }
+}
+
+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
+  }
+
+  try {
+    const result = await createNewProject({
+      guild,
+      projectName,
+      appId,
+      botName: command.client.user?.username,
+    })
+
+    if (!result) {
+      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 projectDirectory = path.join(getProjectsDir(), sanitizedName)
+      await command.editReply(
+        `Project directory already exists: ${projectDirectory}`,
+      )
+      return
+    }
+
+    const {
+      textChannelId,
+      voiceChannelId,
+      channelName,
+      projectDirectory,
+      sanitizedName,
+    } = result
+    const textChannel = (await guild.channels.fetch(
+      textChannelId,
+    )) as TextChannel
+
+    const voiceInfo = voiceChannelId ? `\n🔊 Voice: <#${voiceChannelId}>` : ''
+    await command.editReply(
+      `✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>${voiceInfo}\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',
+    })
+
+    // Add user to thread so it appears in their sidebar
+    await thread.members.add(command.user.id)
+
+    await handleOpencodeSession({
+      prompt:
+        'The project was just initialized. Say hi and ask what the user wants to build.',
+      thread,
+      projectDirectory,
+      channelId: textChannel.id,
+      appId,
+    })
+
+    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/diff.ts

@@ -0,0 +1,165 @@
+// /diff command - Show git diff as a shareable URL.
+
+import {
+  ChannelType,
+  EmbedBuilder,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import path from 'node:path'
+import type { CommandContext } from './types.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { execAsync } from '../worktree-utils.js'
+
+const logger = createLogger(LogPrefix.DIFF)
+
+export async function handleDiffCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  const isTextChannel = channel.type === ChannelType.GuildText
+
+  if (!isThread && !isTextChannel) {
+    await command.reply({
+      content: 'This command can only be used in a text channel or thread',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const resolved = await resolveWorkingDirectory({
+    channel: channel as TextChannel | ThreadChannel,
+  })
+
+  if (!resolved) {
+    await command.reply({
+      content: 'Could not determine project directory for this channel',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const { workingDirectory } = resolved
+
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  try {
+    const projectName = path.basename(workingDirectory)
+    const title = `${projectName}: Discord /diff`
+    const { stdout, stderr } = await execAsync(
+      `bunx critique --web "${title}" --json`,
+      {
+        cwd: workingDirectory,
+        timeout: 30000,
+      },
+    )
+
+    // critique --json outputs JSON on the last line: {"url":"...","id":"..."} or {"error":"..."}
+    const output = stdout || stderr
+    const lines = output.trim().split('\n')
+    const jsonLine = lines[lines.length - 1]
+    if (!jsonLine) {
+      await command.editReply({
+        content: 'No changes to show',
+      })
+      return
+    }
+
+    let result: { url?: string; id?: string; error?: string }
+    try {
+      result = JSON.parse(jsonLine)
+    } catch {
+      // Fallback: try to find URL in output
+      const urlMatch = output.match(/https?:\/\/critique\.work\/[^\s]+/)
+      if (urlMatch) {
+        await command.editReply({
+          content: `[diff](${urlMatch[0]})`,
+        })
+        logger.log(`Diff shared: ${urlMatch[0]}`)
+        return
+      }
+      await command.editReply({
+        content: 'No changes to show',
+      })
+      return
+    }
+
+    if (result.error || !result.url || !result.id) {
+      await command.editReply({
+        content: result.error || 'No changes to show',
+      })
+      return
+    }
+
+    const imageUrl = `https://critique.work/og/${result.id}.png`
+    const embed = new EmbedBuilder()
+      .setTitle(title)
+      .setURL(result.url)
+      .setImage(imageUrl)
+
+    await command.editReply({
+      embeds: [embed],
+    })
+    logger.log(`Diff shared: ${result.url}`)
+  } catch (error) {
+    logger.error('[DIFF] Error:', error)
+
+    // exec error includes stdout/stderr - try to parse JSON from it
+    const execError = error as {
+      stdout?: string
+      stderr?: string
+      message?: string
+    }
+    const output = execError.stdout || execError.stderr || ''
+
+    // Check if critique output JSON even on error
+    const lines = output.trim().split('\n')
+    const jsonLine = lines[lines.length - 1]
+    if (jsonLine) {
+      try {
+        const result = JSON.parse(jsonLine) as { error?: string }
+        if (result.error) {
+          await command.editReply({
+            content: result.error,
+          })
+          return
+        }
+      } catch {
+        // not JSON, continue to generic error
+      }
+    }
+
+    // Check for common errors
+    const message = execError.message || 'Unknown error'
+    if (message.includes('command not found') || message.includes('ENOENT')) {
+      await command.editReply({
+        content: 'bunx/critique not available',
+      })
+      return
+    }
+
+    await command.editReply({
+      content: `Failed to generate diff: ${message.slice(0, 200)}`,
+    })
+  }
+}