afk-code 0.1.0 → 0.1.3

package/src/discord/channel-manager.ts

@@ -1,191 +0,0 @@
-import type { Client, TextChannel, CategoryChannel, Guild } from 'discord.js';
-import { ChannelType, PermissionFlagsBits } from 'discord.js';
-
-export interface ChannelMapping {
-  sessionId: string;
-  channelId: string;
-  channelName: string;
-  sessionName: string;
-  status: 'running' | 'idle' | 'ended';
-  createdAt: Date;
-}
-
-/**
- * Sanitize a string for use as a Discord channel name.
- * Rules: lowercase, no spaces, max 100 chars, only letters/numbers/hyphens/underscores
- */
-function sanitizeChannelName(name: string): string {
-  return name
-    .toLowerCase()
-    .replace(/[^a-z0-9-_\s]/g, '') // Remove invalid chars
-    .replace(/\s+/g, '-') // Spaces to hyphens
-    .replace(/-+/g, '-') // Collapse multiple hyphens
-    .replace(/^-|-$/g, '') // Trim hyphens from ends
-    .slice(0, 90); // Leave room for "afk-" prefix and uniqueness suffix
-}
-
-export class ChannelManager {
-  private channels = new Map<string, ChannelMapping>();
-  private channelToSession = new Map<string, string>();
-  private client: Client;
-  private userId: string;
-  private guild: Guild | null = null;
-  private category: CategoryChannel | null = null;
-
-  constructor(client: Client, userId: string) {
-    this.client = client;
-    this.userId = userId;
-  }
-
-  async initialize(): Promise<void> {
-    // Find the first guild the bot is in
-    const guilds = await this.client.guilds.fetch();
-    if (guilds.size === 0) {
-      throw new Error('Bot is not in any servers. Please invite the bot first.');
-    }
-
-    const guildId = guilds.first()!.id;
-    this.guild = await this.client.guilds.fetch(guildId);
-
-    // Find or create AFK Code category
-    const existingCategory = this.guild.channels.cache.find(
-      (ch) => ch.type === ChannelType.GuildCategory && ch.name.toLowerCase() === 'afk code sessions'
-    ) as CategoryChannel | undefined;
-
-    if (existingCategory) {
-      this.category = existingCategory;
-    } else {
-      this.category = await this.guild.channels.create({
-        name: 'AFK Code Sessions',
-        type: ChannelType.GuildCategory,
-      });
-    }
-
-    console.log(`[ChannelManager] Using guild: ${this.guild.name}`);
-    console.log(`[ChannelManager] Using category: ${this.category.name}`);
-  }
-
-  async createChannel(
-    sessionId: string,
-    sessionName: string,
-    cwd: string
-  ): Promise<ChannelMapping | null> {
-    if (!this.guild || !this.category) {
-      console.error('[ChannelManager] Not initialized');
-      return null;
-    }
-
-    // Check if channel already exists for this session
-    if (this.channels.has(sessionId)) {
-      return this.channels.get(sessionId)!;
-    }
-
-    // Extract just the folder name from the path
-    const folderName = cwd.split('/').filter(Boolean).pop() || 'session';
-    const baseName = `afk-${sanitizeChannelName(folderName)}`;
-
-    // Try to create channel, incrementing suffix if name is taken
-    let channelName = baseName;
-    let suffix = 1;
-    let channel: TextChannel | null = null;
-
-    while (true) {
-      const nameToTry = channelName.length > 100 ? channelName.slice(0, 100) : channelName;
-
-      // Check if name exists
-      const existing = this.guild.channels.cache.find(
-        (ch) => ch.name === nameToTry && ch.parentId === this.category!.id
-      );
-
-      if (!existing) {
-        try {
-          channel = await this.guild.channels.create({
-            name: nameToTry,
-            type: ChannelType.GuildText,
-            parent: this.category,
-            topic: `Claude Code session: ${sessionName}`,
-          });
-          channelName = nameToTry;
-          break;
-        } catch (err: any) {
-          console.error('[ChannelManager] Failed to create channel:', err.message);
-          return null;
-        }
-      } else {
-        suffix++;
-        channelName = `${baseName}-${suffix}`;
-      }
-    }
-
-    if (!channel) {
-      return null;
-    }
-
-    const mapping: ChannelMapping = {
-      sessionId,
-      channelId: channel.id,
-      channelName,
-      sessionName,
-      status: 'running',
-      createdAt: new Date(),
-    };
-
-    this.channels.set(sessionId, mapping);
-    this.channelToSession.set(channel.id, sessionId);
-
-    console.log(`[ChannelManager] Created channel #${channelName} for session ${sessionId}`);
-    return mapping;
-  }
-
-  async archiveChannel(sessionId: string): Promise<boolean> {
-    if (!this.guild) return false;
-
-    const mapping = this.channels.get(sessionId);
-    if (!mapping) return false;
-
-    try {
-      const channel = await this.guild.channels.fetch(mapping.channelId);
-      if (channel && channel.type === ChannelType.GuildText) {
-        // Rename with archived suffix
-        const timestamp = Date.now().toString(36);
-        const archivedName = `${mapping.channelName}-archived-${timestamp}`.slice(0, 100);
-
-        await channel.setName(archivedName);
-
-        // Move out of category or delete (Discord doesn't have archive)
-        // For now, just rename to indicate it's archived
-        console.log(`[ChannelManager] Archived channel #${mapping.channelName}`);
-      }
-      return true;
-    } catch (err: any) {
-      console.error('[ChannelManager] Failed to archive channel:', err.message);
-      return false;
-    }
-  }
-
-  getChannel(sessionId: string): ChannelMapping | undefined {
-    return this.channels.get(sessionId);
-  }
-
-  getSessionByChannel(channelId: string): string | undefined {
-    return this.channelToSession.get(channelId);
-  }
-
-  updateStatus(sessionId: string, status: 'running' | 'idle' | 'ended'): void {
-    const mapping = this.channels.get(sessionId);
-    if (mapping) {
-      mapping.status = status;
-    }
-  }
-
-  updateName(sessionId: string, name: string): void {
-    const mapping = this.channels.get(sessionId);
-    if (mapping) {
-      mapping.sessionName = name;
-    }
-  }
-
-  getAllActive(): ChannelMapping[] {
-    return Array.from(this.channels.values()).filter((c) => c.status !== 'ended');
-  }
-}

package/src/discord/discord-app.ts

@@ -1,359 +0,0 @@
-import { Client, GatewayIntentBits, Events, ChannelType, AttachmentBuilder, REST, Routes, SlashCommandBuilder } from 'discord.js';
-import type { DiscordConfig } from './types';
-import { SessionManager, type SessionInfo, type ToolCallInfo, type ToolResultInfo } from '../slack/session-manager';
-import { ChannelManager } from './channel-manager';
-import { markdownToSlack, chunkMessage, formatSessionStatus, formatTodos } from '../slack/message-formatter';
-import { extractImagePaths } from '../utils/image-extractor';
-
-export function createDiscordApp(config: DiscordConfig) {
-  const client = new Client({
-    intents: [
-      GatewayIntentBits.Guilds,
-      GatewayIntentBits.GuildMessages,
-      GatewayIntentBits.MessageContent,
-    ],
-  });
-
-  const channelManager = new ChannelManager(client, config.userId);
-
-  // Track messages sent from Discord to avoid re-posting
-  const discordSentMessages = new Set<string>();
-
-  // Track tool call messages for threading results
-  const toolCallMessages = new Map<string, string>(); // toolUseId -> message id
-
-  // Create session manager with event handlers that post to Discord
-  const sessionManager = new SessionManager({
-    onSessionStart: async (session) => {
-      const channel = await channelManager.createChannel(session.id, session.name, session.cwd);
-      if (channel) {
-        const discordChannel = await client.channels.fetch(channel.channelId);
-        if (discordChannel?.type === ChannelType.GuildText) {
-          await discordChannel.send(
-            `${formatSessionStatus(session.status)} **Session started**\n\`${session.cwd}\``
-          );
-        }
-      }
-    },
-
-    onSessionEnd: async (sessionId) => {
-      const channel = channelManager.getChannel(sessionId);
-      if (channel) {
-        channelManager.updateStatus(sessionId, 'ended');
-
-        const discordChannel = await client.channels.fetch(channel.channelId);
-        if (discordChannel?.type === ChannelType.GuildText) {
-          await discordChannel.send('🛑 **Session ended** - this channel will be archived');
-        }
-
-        await channelManager.archiveChannel(sessionId);
-      }
-    },
-
-    onSessionUpdate: async (sessionId, name) => {
-      const channel = channelManager.getChannel(sessionId);
-      if (channel) {
-        channelManager.updateName(sessionId, name);
-        // Update channel topic
-        try {
-          const discordChannel = await client.channels.fetch(channel.channelId);
-          if (discordChannel?.type === ChannelType.GuildText) {
-            await discordChannel.setTopic(`Claude Code session: ${name}`);
-          }
-        } catch (err) {
-          console.error('[Discord] Failed to update channel topic:', err);
-        }
-      }
-    },
-
-    onSessionStatus: async (sessionId, status) => {
-      const channel = channelManager.getChannel(sessionId);
-      if (channel) {
-        channelManager.updateStatus(sessionId, status);
-      }
-    },
-
-    onMessage: async (sessionId, role, content) => {
-      const channel = channelManager.getChannel(sessionId);
-      if (channel) {
-        // Discord markdown is similar to Slack's mrkdwn but uses standard markdown
-        const formatted = content; // Discord uses standard markdown
-
-        if (role === 'user') {
-          // Skip messages that originated from Discord
-          const contentKey = content.trim();
-          if (discordSentMessages.has(contentKey)) {
-            discordSentMessages.delete(contentKey);
-            return;
-          }
-
-          // User message from terminal
-          const discordChannel = await client.channels.fetch(channel.channelId);
-          if (discordChannel?.type === ChannelType.GuildText) {
-            const chunks = chunkMessage(formatted);
-            for (const chunk of chunks) {
-              await discordChannel.send(`**User:** ${chunk}`);
-            }
-          }
-        } else {
-          // Claude's response
-          const discordChannel = await client.channels.fetch(channel.channelId);
-          if (discordChannel?.type === ChannelType.GuildText) {
-            const chunks = chunkMessage(formatted);
-            for (const chunk of chunks) {
-              await discordChannel.send(chunk);
-            }
-
-            // Extract and upload any images mentioned in the response
-            const session = sessionManager.getSession(sessionId);
-            const images = extractImagePaths(content, session?.cwd);
-            for (const image of images) {
-              try {
-                console.log(`[Discord] Uploading image: ${image.resolvedPath}`);
-                const attachment = new AttachmentBuilder(image.resolvedPath);
-                await discordChannel.send({
-                  content: `📎 ${image.originalPath}`,
-                  files: [attachment],
-                });
-              } catch (err) {
-                console.error('[Discord] Failed to upload image:', err);
-              }
-            }
-          }
-        }
-      }
-    },
-
-    onTodos: async (sessionId, todos) => {
-      const channel = channelManager.getChannel(sessionId);
-      if (channel && todos.length > 0) {
-        const todosText = formatTodos(todos);
-        try {
-          const discordChannel = await client.channels.fetch(channel.channelId);
-          if (discordChannel?.type === ChannelType.GuildText) {
-            await discordChannel.send(`**Tasks:**\n${todosText}`);
-          }
-        } catch (err) {
-          console.error('[Discord] Failed to post todos:', err);
-        }
-      }
-    },
-
-    onToolCall: async (sessionId, tool) => {
-      const channel = channelManager.getChannel(sessionId);
-      if (!channel) return;
-
-      // Format tool call summary
-      let inputSummary = '';
-      if (tool.name === 'Bash' && tool.input.command) {
-        inputSummary = `\`${tool.input.command.slice(0, 100)}${tool.input.command.length > 100 ? '...' : ''}\``;
-      } else if (tool.name === 'Read' && tool.input.file_path) {
-        inputSummary = `\`${tool.input.file_path}\``;
-      } else if (tool.name === 'Edit' && tool.input.file_path) {
-        inputSummary = `\`${tool.input.file_path}\``;
-      } else if (tool.name === 'Write' && tool.input.file_path) {
-        inputSummary = `\`${tool.input.file_path}\``;
-      } else if (tool.name === 'Grep' && tool.input.pattern) {
-        inputSummary = `\`${tool.input.pattern}\``;
-      } else if (tool.name === 'Glob' && tool.input.pattern) {
-        inputSummary = `\`${tool.input.pattern}\``;
-      } else if (tool.name === 'Task' && tool.input.description) {
-        inputSummary = tool.input.description;
-      }
-
-      const text = inputSummary
-        ? `🔧 **${tool.name}**: ${inputSummary}`
-        : `🔧 **${tool.name}**`;
-
-      try {
-        const discordChannel = await client.channels.fetch(channel.channelId);
-        if (discordChannel?.type === ChannelType.GuildText) {
-          const message = await discordChannel.send(text);
-          // Store the message id for threading results
-          toolCallMessages.set(tool.id, message.id);
-        }
-      } catch (err) {
-        console.error('[Discord] Failed to post tool call:', err);
-      }
-    },
-
-    onToolResult: async (sessionId, result) => {
-      const channel = channelManager.getChannel(sessionId);
-      if (!channel) return;
-
-      const parentMessageId = toolCallMessages.get(result.toolUseId);
-      if (!parentMessageId) return; // No parent message to reply to
-
-      // Truncate long results
-      const maxLen = 1800; // Discord has 2000 char limit
-      let content = result.content;
-      if (content.length > maxLen) {
-        content = content.slice(0, maxLen) + '\n... (truncated)';
-      }
-
-      const prefix = result.isError ? '❌ Error:' : '✅ Result:';
-      const text = `${prefix}\n\`\`\`\n${content}\n\`\`\``;
-
-      try {
-        const discordChannel = await client.channels.fetch(channel.channelId);
-        if (discordChannel?.type === ChannelType.GuildText) {
-          // Fetch the parent message and create a thread
-          const parentMessage = await discordChannel.messages.fetch(parentMessageId);
-          if (parentMessage) {
-            // Create a thread if one doesn't exist, or use existing
-            let thread = parentMessage.thread;
-            if (!thread) {
-              thread = await parentMessage.startThread({
-                name: 'Result',
-                autoArchiveDuration: 60,
-              });
-            }
-            await thread.send(text);
-          }
-
-          // Clean up the mapping
-          toolCallMessages.delete(result.toolUseId);
-        }
-      } catch (err) {
-        console.error('[Discord] Failed to post tool result:', err);
-      }
-    },
-
-    onPlanModeChange: async (sessionId, inPlanMode) => {
-      const channel = channelManager.getChannel(sessionId);
-      if (!channel) return;
-
-      const emoji = inPlanMode ? '📋' : '🔨';
-      const status = inPlanMode ? 'Planning mode - Claude is designing a solution' : 'Execution mode - Claude is implementing';
-
-      try {
-        const discordChannel = await client.channels.fetch(channel.channelId);
-        if (discordChannel?.type === ChannelType.GuildText) {
-          await discordChannel.send(`${emoji} ${status}`);
-        }
-      } catch (err) {
-        console.error('[Discord] Failed to post plan mode change:', err);
-      }
-    },
-  });
-
-  // Handle messages in session channels (user sending input to Claude)
-  client.on(Events.MessageCreate, async (message) => {
-    // Ignore bot's own messages
-    if (message.author.bot) return;
-
-    // Ignore DMs
-    if (!message.guild) return;
-
-    const sessionId = channelManager.getSessionByChannel(message.channelId);
-    if (!sessionId) return; // Not a session channel
-
-    const channel = channelManager.getChannel(sessionId);
-    if (!channel || channel.status === 'ended') {
-      await message.reply('⚠️ This session has ended.');
-      return;
-    }
-
-    console.log(`[Discord] Sending input to session ${sessionId}: ${message.content.slice(0, 50)}...`);
-
-    // Track this message so we don't re-post it
-    discordSentMessages.add(message.content.trim());
-
-    const sent = sessionManager.sendInput(sessionId, message.content);
-    if (!sent) {
-      discordSentMessages.delete(message.content.trim());
-      await message.reply('⚠️ Failed to send input - session not connected.');
-    }
-  });
-
-  // When bot is ready
-  client.once(Events.ClientReady, async (c) => {
-    console.log(`[Discord] Logged in as ${c.user.tag}`);
-    await channelManager.initialize();
-
-    // Register slash commands
-    const commands = [
-      new SlashCommandBuilder()
-        .setName('background')
-        .setDescription('Send Claude to background mode (Ctrl+B)'),
-      new SlashCommandBuilder()
-        .setName('interrupt')
-        .setDescription('Interrupt Claude (Escape)'),
-      new SlashCommandBuilder()
-        .setName('mode')
-        .setDescription('Toggle Claude mode (Shift+Tab)'),
-      new SlashCommandBuilder()
-        .setName('afk')
-        .setDescription('List active Claude Code sessions'),
-    ];
-
-    try {
-      const rest = new REST({ version: '10' }).setToken(config.botToken);
-      await rest.put(Routes.applicationCommands(c.user.id), {
-        body: commands.map((cmd) => cmd.toJSON()),
-      });
-      console.log('[Discord] Slash commands registered');
-    } catch (err) {
-      console.error('[Discord] Failed to register slash commands:', err);
-    }
-  });
-
-  // Handle slash commands
-  client.on(Events.InteractionCreate, async (interaction) => {
-    if (!interaction.isChatInputCommand()) return;
-
-    const { commandName, channelId } = interaction;
-
-    if (commandName === 'afk') {
-      const active = channelManager.getAllActive();
-      if (active.length === 0) {
-        await interaction.reply('No active sessions. Start a session with `afk-code run -- claude`');
-        return;
-      }
-
-      const text = active
-        .map((c) => `<#${c.channelId}> - ${formatSessionStatus(c.status)}`)
-        .join('\n');
-
-      await interaction.reply(`**Active Sessions:**\n${text}`);
-      return;
-    }
-
-    if (commandName === 'background' || commandName === 'interrupt' || commandName === 'mode') {
-      const sessionId = channelManager.getSessionByChannel(channelId);
-      if (!sessionId) {
-        await interaction.reply('⚠️ This channel is not associated with an active session.');
-        return;
-      }
-
-      const channel = channelManager.getChannel(sessionId);
-      if (!channel || channel.status === 'ended') {
-        await interaction.reply('⚠️ This session has ended.');
-        return;
-      }
-
-      // Send the appropriate escape sequence
-      let key: string;
-      let message: string;
-      if (commandName === 'background') {
-        key = '\x02'; // Ctrl+B
-        message = '⬇️ Sent background command (Ctrl+B)';
-      } else if (commandName === 'interrupt') {
-        key = '\x1b'; // Escape
-        message = '🛑 Sent interrupt (Escape)';
-      } else {
-        key = '\x1b[Z'; // Shift+Tab
-        message = '🔄 Sent mode toggle (Shift+Tab)';
-      }
-
-      const sent = sessionManager.sendInput(sessionId, key);
-      if (sent) {
-        await interaction.reply(message);
-      } else {
-        await interaction.reply('⚠️ Failed to send command - session not connected.');
-      }
-    }
-  });
-
-  return { client, sessionManager, channelManager };
-}

package/src/discord/types.ts

@@ -1,4 +0,0 @@
-export interface DiscordConfig {
-  botToken: string;
-  userId: string; // User to notify
-}