@otto-assistant/otto 0.1.2 → 0.7.16

package/src/commands/compact.ts

@@ -0,0 +1,157 @@
+// /compact command - Trigger context compaction (summarization) for the current session.
+
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getThreadSession } from '../database.js'
+import {
+  initializeOpencodeForDirectory,
+  getOpencodeClient,
+} from '../opencode.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const logger = createLogger(LogPrefix.COMPACT)
+
+export async function handleCompactCommand({
+  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)
+
+  if (!isThread) {
+    await command.reply({
+      content:
+        'This command can only be used in a thread with an active session',
+      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 { projectDirectory, workingDirectory } = resolved
+
+  const sessionId = await getThreadSession(channel.id)
+
+  if (!sessionId) {
+    await command.reply({
+      content: 'No active session in this thread',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  // Ensure server is running for the base project directory
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    await command.reply({
+      content: `Failed to compact: ${getClient.message}`,
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const client = getOpencodeClient(projectDirectory)
+  if (!client) {
+    await command.reply({
+      content: 'Failed to get OpenCode client',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  // Defer reply since compaction may take a moment
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  try {
+    // Get session messages to find the model from the last user message
+    const messagesResult = await client.session.messages({
+      sessionID: sessionId,
+      directory: workingDirectory,
+    })
+
+    if (messagesResult.error || !messagesResult.data) {
+      logger.error('[COMPACT] Failed to get messages:', messagesResult.error)
+      await command.editReply({
+        content: 'Failed to compact: Could not retrieve session messages',
+      })
+      return
+    }
+
+    // Find the last user message to get the model
+    const lastUserMessage = [...messagesResult.data]
+      .reverse()
+      .find((msg) => msg.info.role === 'user')
+
+    if (!lastUserMessage || lastUserMessage.info.role !== 'user') {
+      await command.editReply({
+        content: 'Failed to compact: No user message found in session',
+      })
+      return
+    }
+
+    const { providerID, modelID } = lastUserMessage.info.model
+
+    const result = await client.session.summarize({
+      sessionID: sessionId,
+      directory: workingDirectory,
+      providerID,
+      modelID,
+      auto: false,
+    })
+
+    if (result.error) {
+      logger.error('[COMPACT] Error:', result.error)
+      const errorMessage =
+        'data' in result.error && result.error.data
+          ? (result.error.data as { message?: string }).message ||
+            'Unknown error'
+          : 'Unknown error'
+      await command.editReply({
+        content: `Failed to compact: ${errorMessage}`,
+      })
+      return
+    }
+
+    await command.editReply({
+      content: `📦 Session **compacted** successfully`,
+    })
+    logger.log(`Session ${sessionId} compacted by user`)
+  } catch (error) {
+    logger.error('[COMPACT] Error:', error)
+    await command.editReply({
+      content: `Failed to compact: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+  }
+}

package/src/commands/context-usage.ts

@@ -0,0 +1,199 @@
+// /context-usage command - Show token usage and context window percentage for the current session.
+
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getThreadSession } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import * as errore from 'errore'
+
+const logger = createLogger(LogPrefix.SESSION)
+
+function getTokenTotal({
+  input,
+  output,
+  reasoning,
+  cache,
+}: {
+  input: number
+  output: number
+  reasoning: number
+  cache: { read: number; write: number }
+}): number {
+  return input + output + reasoning + cache.read + cache.write
+}
+
+export async function handleContextUsageCommand({
+  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)
+
+  if (!isThread) {
+    await command.reply({
+      content:
+        'This command can only be used in a thread with an active session',
+      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 { projectDirectory, workingDirectory } = resolved
+
+  const sessionId = await getThreadSession(channel.id)
+
+  if (!sessionId) {
+    await command.reply({
+      content: 'No active session in this thread',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    await command.reply({
+      content: `Failed to get context usage: ${getClient.message}`,
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  try {
+    const messagesResponse = await getClient().session.messages({
+      sessionID: sessionId,
+      directory: workingDirectory,
+    })
+
+    const messages = messagesResponse.data || []
+    const assistantMessages = messages.filter(
+      (m) => m.info.role === 'assistant',
+    )
+
+    if (assistantMessages.length === 0) {
+      await command.editReply({
+        content: 'No assistant messages in this session yet',
+      })
+      return
+    }
+
+    const lastAssistant = [...assistantMessages].reverse().find((m) => {
+      if (m.info.role !== 'assistant') {
+        return false
+      }
+      if (!m.info.tokens) {
+        return false
+      }
+      return getTokenTotal(m.info.tokens) > 0
+    })
+
+    if (!lastAssistant || lastAssistant.info.role !== 'assistant') {
+      await command.editReply({
+        content: 'Token usage not available for this session yet',
+      })
+      return
+    }
+
+    const { tokens, modelID, providerID } = lastAssistant.info
+    const totalTokens = getTokenTotal(tokens)
+
+    // Sum cost across all assistant messages for accurate session total
+    // (AssistantMessage.cost is per-message, not cumulative)
+    const totalCost = assistantMessages.reduce((sum, m) => {
+      if (m.info.role === 'assistant' && 'cost' in m.info) {
+        return sum + (m.info.cost || 0)
+      }
+      return sum
+    }, 0)
+
+    // Fetch model context limit from provider API
+    let contextLimit: number | undefined
+    const providersResult = await errore.tryAsync(() => {
+      return getClient().provider.list({ directory: workingDirectory })
+    })
+    if (providersResult instanceof Error) {
+      logger.error(
+        '[CONTEXT-USAGE] Failed to fetch provider info:',
+        providersResult,
+      )
+    } else {
+      const provider = providersResult.data?.all?.find(
+        (p) => p.id === providerID,
+      )
+      const model = provider?.models?.[modelID]
+      if (model?.limit?.context) {
+        contextLimit = model.limit.context
+      }
+    }
+
+    const formattedTokens = totalTokens.toLocaleString('en-US')
+    const formattedCost = totalCost > 0 ? `$${totalCost.toFixed(4)}` : '$0.00'
+
+    const lines: string[] = []
+
+    if (contextLimit) {
+      const percentage = Math.round((totalTokens / contextLimit) * 100)
+      const formattedLimit = contextLimit.toLocaleString('en-US')
+      lines.push(
+        `**Context usage:** ${percentage}%, ${formattedTokens} / ${formattedLimit} tokens`,
+      )
+    } else {
+      lines.push(
+        `**Context usage:** ${formattedTokens} tokens (context limit unavailable)`,
+      )
+    }
+
+    if (modelID) {
+      lines.push(`**Model:** ${modelID}`)
+    }
+    if (totalCost > 0) {
+      lines.push(`**Session cost:** ${formattedCost}`)
+    }
+
+    await command.editReply({ content: lines.join('\n') })
+    logger.log(
+      `Context usage shown for session ${sessionId}: ${totalTokens} tokens`,
+    )
+  } catch (error) {
+    logger.error('[CONTEXT-USAGE] Error:', error)
+    await command.editReply({
+      content: `Failed to get context usage: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+  }
+}

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

@@ -0,0 +1,190 @@
+// /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 { execAsync } from '../worktrees.js'
+import type { CommandContext } from './types.js'
+import { getProjectsDir } from '../config.js'
+import { createProjectChannels } from '../channel-management.js'
+import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.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,
+  botName,
+}: {
+  guild: Guild
+  projectName: 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}`)
+
+  // Git init — gracefully skip if git is not installed
+  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)}`,
+    )
+  }
+
+  const { textChannelId, voiceChannelId, channelName } =
+    await createProjectChannels({
+      guild,
+      projectDirectory,
+      botName,
+    })
+
+  return {
+    textChannelId,
+    voiceChannelId,
+    channelName,
+    projectDirectory,
+    sanitizedName,
+  }
+}
+
+export async function handleCreateNewProjectCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  await command.deferReply()
+
+  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,
+      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)
+
+    const runtime = getOrCreateRuntime({
+      threadId: thread.id,
+      thread,
+      projectDirectory,
+      sdkDirectory: projectDirectory,
+      channelId: textChannel.id,
+      appId,
+    })
+    await runtime.enqueueIncoming({
+      prompt:
+        'The project was just initialized. Say hi and ask what the user wants to build.',
+      userId: command.user.id,
+      username: command.user.displayName,
+      appId,
+      mode: 'opencode',
+    })
+
+    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,91 @@
+// /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 { uploadGitDiffViaCritique } from '../critique-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 })
+
+  const projectName = path.basename(workingDirectory)
+  const title = `${projectName}: Discord /diff`
+  const result = await uploadGitDiffViaCritique({
+    title,
+    cwd: workingDirectory,
+  })
+
+  if (!result) {
+    await command.editReply({ content: 'No changes to show' })
+    return
+  }
+
+  if (result.error || !result.url) {
+    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}`)
+}