feat: add thread-per-session support (#19)

Author: zebbern

claude/command.ts

@@ -3,28 +3,70 @@ import { sendToClaudeCode, type ClaudeModelOptions } from "./client.ts";
 import { convertToClaudeMessages } from "./message-converter.ts";
 import { SlashCommandBuilder } from "npm:discord.js@14.14.1";
 
+// Callback that creates (or retrieves) a session thread and returns a
+// sender function bound to that thread.
+export interface SessionThreadCallbacks {
+  /**
+   * Create a new Discord thread for this session and return a sender bound to it.
+   * Also posts a summary embed in the main channel linking to the thread.
+   *
+   * @param prompt The user's prompt (used to name the thread)
+   * @param sessionId Optional pre-existing session ID (reuses thread if one exists)
+   * @returns Object with the thread-bound sender and a placeholder session key
+   */
+  createThreadSender(prompt: string, sessionId?: string, threadName?: string): Promise<{
+    sender: (messages: ClaudeMessage[]) => Promise<void>;
+    threadSessionKey: string;
+    threadChannelId: string;
+  }>;
+  /**
+   * Look up an existing thread for a session (does NOT create one).
+   * Returns undefined if the session has no thread.
+   */
+  getThreadSender(sessionId: string): Promise<{
+    sender: (messages: ClaudeMessage[]) => Promise<void>;
+    threadSessionKey: string;
+  } | undefined>;
+  /**
+   * Update the session key mapping when the real SDK session ID arrives.
+   */
+  updateSessionId(oldKey: string, newSessionId: string): void;
+}
+
 // Discord command definitions
 export const claudeCommands = [
   new SlashCommandBuilder()
     .setName('claude')
-    .setDescription('Send message to Claude Code')
+    .setDescription('Send message to Claude Code (auto-continues in current channel)')
     .addStringOption(option =>
       option.setName('prompt')
         .setDescription('Prompt for Claude Code')
         .setRequired(true))
     .addStringOption(option =>
       option.setName('session_id')
-        .setDescription('Session ID to continue (optional)')
+        .setDescription('Session ID to resume (optional)')
         .setRequired(false)),
-  
+
+  new SlashCommandBuilder()
+    .setName('claude-thread')
+    .setDescription('Start a new Claude session in a dedicated thread')
+    .addStringOption(option =>
+      option.setName('name')
+        .setDescription('Thread name')
+        .setRequired(true))
+    .addStringOption(option =>
+      option.setName('prompt')
+        .setDescription('Prompt for Claude Code')
+        .setRequired(true)),
+
   new SlashCommandBuilder()
     .setName('resume')
-    .setDescription('Resume the previous Claude Code session')
+    .setDescription('Resume the most recent Claude Code session (across all channels)')
     .addStringOption(option =>
       option.setName('prompt')
         .setDescription('Prompt for Claude Code (optional)')
         .setRequired(false)),
-  
+
   new SlashCommandBuilder()
     .setName('claude-cancel')
     .setDescription('Cancel currently running Claude Code command'),
@@ -34,134 +76,257 @@ export interface ClaudeHandlerDeps {
   workDir: string;
   getClaudeController: () => AbortController | null;
   setClaudeController: (controller: AbortController | null) => void;
+  /** Get session ID for a specific channel/thread (per-channel tracking) */
+  getSessionForChannel: (channelId: string) => string | undefined;
+  /** Set session ID for a specific channel/thread */
+  setSessionForChannel: (channelId: string, sessionId: string | undefined) => void;
+  /** Legacy global getter (for /resume — find most recent across channels) */
+  getClaudeSessionId: () => string | undefined;
+  /** Legacy global setter (keeps backward compat for session manager) */
   setClaudeSessionId: (sessionId: string | undefined) => void;
+  /** Default sender — used when no thread is available (fallback) */
   sendClaudeMessages: (messages: ClaudeMessage[]) => Promise<void>;
   /** Get current runtime options from unified settings (thinking, operation, proxy) */
   getQueryOptions?: () => ClaudeModelOptions;
+  /** Thread-per-session callbacks (optional — when absent, falls back to main channel) */
+  sessionThreads?: SessionThreadCallbacks;
 }
 
 export function createClaudeHandlers(deps: ClaudeHandlerDeps) {
   const { workDir, sendClaudeMessages } = deps;
-  
+
   return {
+    /**
+     * /claude — Send a message to Claude. Auto-continues the session active in the
+     * current channel/thread. Starts a new session only if there isn't one yet.
+     */
+    // deno-lint-ignore no-explicit-any
+    async onClaude(ctx: any, prompt: string, channelId: string, explicitSessionId?: string): Promise<ClaudeResponse> {
+      const existingController = deps.getClaudeController();
+      if (existingController) {
+        existingController.abort();
+      }
+
+      const controller = new AbortController();
+      deps.setClaudeController(controller);
+
+      await ctx.deferReply();
+
+      // Resolve which session to resume:
+      // 1) Explicit session_id from user → resume that
+      // 2) Active session in this channel/thread → resume that
+      // 3) None → start a new session
+      const activeSessionId = explicitSessionId || deps.getSessionForChannel(channelId);
+
+      // Pick the right sender — if this channel has a thread, use it
+      let activeSender = sendClaudeMessages;
+      if (activeSessionId && deps.sessionThreads) {
+        try {
+          const existing = await deps.sessionThreads.getThreadSender(activeSessionId);
+          if (existing) {
+            activeSender = existing.sender;
+          }
+        } catch { /* fallback to main sender */ }
+      }
+
+      const isResuming = !!activeSessionId;
+
+      await ctx.editReply({
+        embeds: [{
+          color: 0xffff00,
+          title: isResuming ? 'Claude Code Continuing...' : 'Claude Code Running...',
+          description: isResuming ? 'Continuing session...' : 'Starting new session...',
+          fields: [{ name: 'Prompt', value: `\`${prompt.substring(0, 1020)}\``, inline: false }],
+          timestamp: true
+        }]
+      });
+
+      const result = await sendToClaudeCode(
+        workDir,
+        prompt,
+        controller,
+        activeSessionId, // resume if present, new session if undefined
+        undefined,
+        (jsonData) => {
+          const claudeMessages = convertToClaudeMessages(jsonData);
+          if (claudeMessages.length > 0) {
+            activeSender(claudeMessages).catch(() => {});
+          }
+        },
+        false,
+        deps.getQueryOptions?.()
+      );
+
+      // Track session per-channel and globally
+      if (result.sessionId) {
+        deps.setSessionForChannel(channelId, result.sessionId);
+      }
+      deps.setClaudeSessionId(result.sessionId);
+      deps.setClaudeController(null);
+
+      return result;
+    },
+
+    /**
+     * /claude-thread — Start a brand-new session in a dedicated Discord thread.
+     */
     // deno-lint-ignore no-explicit-any
-    async onClaude(ctx: any, prompt: string, sessionId?: string): Promise<ClaudeResponse> {
-      // Cancel any existing session
+    async onClaudeThread(ctx: any, prompt: string, threadName?: string): Promise<ClaudeResponse> {
       const existingController = deps.getClaudeController();
       if (existingController) {
         existingController.abort();
       }
-      
+
       const controller = new AbortController();
       deps.setClaudeController(controller);
-      
-      // Defer interaction (execute first)
+
       await ctx.deferReply();
-      
-      // Send initial message
+
+      // Create a dedicated thread for this session
+      let activeSender = sendClaudeMessages;
+      let threadSessionKey: string | undefined;
+      let threadChannelId: string | undefined;
+
+      if (deps.sessionThreads) {
+        try {
+          const threadResult = await deps.sessionThreads.createThreadSender(prompt, undefined, threadName);
+          activeSender = threadResult.sender;
+          threadSessionKey = threadResult.threadSessionKey;
+          threadChannelId = threadResult.threadChannelId;
+        } catch (err) {
+          console.warn('[SessionThread] Could not create thread, falling back to main channel:', err);
+        }
+      }
+
       await ctx.editReply({
         embeds: [{
           color: 0xffff00,
           title: 'Claude Code Running...',
-          description: 'Waiting for response...',
+          description: threadSessionKey
+            ? 'Session started in a dedicated thread — check below ↓'
+            : 'Starting new session...',
           fields: [{ name: 'Prompt', value: `\`${prompt.substring(0, 1020)}\``, inline: false }],
           timestamp: true
         }]
       });
-      
+
       const result = await sendToClaudeCode(
         workDir,
         prompt,
         controller,
-        sessionId,
-        undefined, // onChunk callback not used
+        undefined, // always a new session
+        undefined,
         (jsonData) => {
-          // Process JSON stream data and send to Discord
           const claudeMessages = convertToClaudeMessages(jsonData);
           if (claudeMessages.length > 0) {
-            sendClaudeMessages(claudeMessages).catch(() => {});
+            activeSender(claudeMessages).catch(() => {});
           }
         },
-        false, // continueMode = false
-        deps.getQueryOptions?.() // Pass runtime settings (thinking, operation, proxy)
+        false,
+        deps.getQueryOptions?.()
       );
-      
+
       deps.setClaudeSessionId(result.sessionId);
       deps.setClaudeController(null);
-      
-      // Completion message is already sent via SDK streaming (result type → message-converter.ts)
-      
+
+      // Map the thread channel → session so /claude inside the thread auto-continues
+      if (threadSessionKey && result.sessionId && deps.sessionThreads) {
+        deps.sessionThreads.updateSessionId(threadSessionKey, result.sessionId);
+      }
+      if (threadChannelId && result.sessionId) {
+        deps.setSessionForChannel(threadChannelId, result.sessionId);
+      }
+
       return result;
     },
-    
+
+    /**
+     * /resume — Continue the most recent session (global, not per-channel).
+     * If that session has a thread, output goes there.
+     */
     // deno-lint-ignore no-explicit-any
     async onContinue(ctx: any, prompt?: string): Promise<ClaudeResponse> {
-      // Cancel any existing session
       const existingController = deps.getClaudeController();
       if (existingController) {
         existingController.abort();
       }
-      
+
       const controller = new AbortController();
       deps.setClaudeController(controller);
-      
+
       const actualPrompt = prompt || "Please continue.";
-      
-      // Defer interaction
+
       await ctx.deferReply();
-      
-      // Send initial message
+
+      // Check if the most recent session has a thread — if so, reuse it
+      let activeSender = sendClaudeMessages;
+      let isReusingThread = false;
+
+      if (deps.sessionThreads) {
+        const currentSessionId = deps.getClaudeSessionId();
+        if (currentSessionId) {
+          try {
+            const existing = await deps.sessionThreads.getThreadSender(currentSessionId);
+            if (existing) {
+              activeSender = existing.sender;
+              isReusingThread = true;
+            }
+          } catch (err) {
+            console.warn('[SessionThread] Could not reuse thread for continue, falling back:', err);
+          }
+        }
+      }
+
       const embedData: { color: number; title: string; description: string; timestamp: boolean; fields?: Array<{ name: string; value: string; inline: boolean }> } = {
         color: 0xffff00,
         title: 'Claude Code Continuing Conversation...',
-        description: 'Loading latest conversation and waiting for response...',
+        description: isReusingThread
+          ? 'Continuing in session thread...'
+          : 'Loading latest conversation and waiting for response...',
         timestamp: true
       };
-      
+
       if (prompt) {
         embedData.fields = [{ name: 'Prompt', value: `\`${prompt.substring(0, 1020)}\``, inline: false }];
       }
-      
+
       await ctx.editReply({ embeds: [embedData] });
-      
+
       const result = await sendToClaudeCode(
         workDir,
         actualPrompt,
         controller,
-        undefined, // sessionId not used
-        undefined, // onChunk callback not used
+        undefined,
+        undefined,
         (jsonData) => {
-          // Process JSON stream data and send to Discord
           const claudeMessages = convertToClaudeMessages(jsonData);
           if (claudeMessages.length > 0) {
-            sendClaudeMessages(claudeMessages).catch(() => {});
+            activeSender(claudeMessages).catch(() => {});
           }
         },
         true, // continueMode = true
-        deps.getQueryOptions?.() // Pass runtime settings (thinking, operation, proxy)
+        deps.getQueryOptions?.()
       );
-      
+
       deps.setClaudeSessionId(result.sessionId);
       deps.setClaudeController(null);
-      
-      // Completion message is already sent via SDK streaming (result type → message-converter.ts)
-      
+
       return result;
     },
-    
+
     // deno-lint-ignore no-explicit-any
     onClaudeCancel(_ctx: any): boolean {
       const currentController = deps.getClaudeController();
       if (!currentController) {
         return false;
       }
-      
+
       console.log("Cancelling Claude Code session...");
       currentController.abort();
       deps.setClaudeController(null);
       deps.setClaudeSessionId(undefined);
-      
+
       return true;
     }
   };
-}
+}