Project Structure

streamer-alerts-bot/
├── src/
│   ├── index.ts                    # Entry point
│   ├── client/
│   │   └── StreamerBot.ts          # Extended Discord client
│   ├── commands/
│   │   ├── index.ts                # Command registration
│   │   ├── streamer/
│   │   │   ├── add.ts              # /streamer add command
│   │   │   ├── remove.ts           # /streamer remove command
│   │   │   ├── list.ts             # /streamer list command
│   │   │   └── index.ts            # Streamer subcommand group
│   │   └── util/
│   │       ├── help.ts             # /help command
│   │       └── ping.ts             # /ping command
│   ├── components/
│   │   ├── buttons.ts              # Discord button components
│   │   ├── embeds.ts               # Discord embed builders
│   │   └── menus.ts                # Select menu components
│   ├── database/
│   │   └── index.ts                # JSON file database
│   ├── events/
│   │   ├── index.ts                # Event registration
│   │   ├── ready.ts                # Ready event handler
│   │   └── interactionCreate.ts   # Interaction handler
│   ├── handlers/
│   │   ├── buttons.ts              # Button interaction handlers
│   │   └── selectMenus.ts          # Select menu handlers
│   ├── platforms/
│   │   ├── index.ts                # Platform checker registry
│   │   ├── types.ts                # Platform type definitions
│   │   ├── kick.ts                 # Kick platform checker
│   │   ├── twitch.ts               # Twitch platform checker
│   │   ├── youtube.ts              # YouTube platform checker
│   │   ├── rumble.ts               # Rumble platform checker
│   │   └── tiktok.ts               # TikTok platform checker
│   ├── services/
│   │   ├── AlertService.ts         # Alert sending service
│   │   └── StreamPoller.ts         # Stream polling service
│   ├── types/
│   │   ├── index.ts                # Type exports
│   │   ├── discord.ts              # Discord-related types
│   │   └── streamer.ts             # Streamer data types
│   └── utils/
│       ├── constants.ts            # App constants and configs
│       ├── formatters.ts           # Display formatters
│       └── logger.ts               # Logging utility
├── data/
│   └── guilds.json                 # Persistent guild data
├── dist/                           # Compiled JavaScript output
├── .env                            # Environment variables
├── .env.example                    # Example env file
├── package.json
├── tsconfig.json
└── README.md

async function main(): Promise<void> {
  const token = process.env.DISCORD_TOKEN;
  if (!token) {
    logger.error("DISCORD_TOKEN is not set");
    process.exit(1);
  }

  const client = createClient();
  registerCommands(client);
  registerEvents(client);
  
  await client.login(token);
}

new Client({
  intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages],
  partials: [Partials.Channel]
})

{
  "guild_id_123": {
    "streamers": [
      {
        "id": "twitch:xqc",
        "platform": "twitch",
        "username": "xqc",
        "channelId": "channel_id_456",
        "isLive": false,
        "title": "Playing Overwatch",
        "viewers": 50000,
        "followers": 1000000,
        "lastLiveAt": "2026-03-01T12:00:00.000Z"
      }
    ]
  }
}

export function handleReady(client: StreamerBot): void {
  logger.info(`Logged in as ${client.user?.tag}`);
  
  client.startActivityRotation();
  
  const poller = createStreamPoller(client);
  poller.start();
}

export function getChecker(platform: Platform): PlatformChecker {
  // Returns appropriate checker function
}

export async function checkKick(username: string): Promise<LiveStatus> {
  // Fetch and parse platform-specific data
}

const lastLiveData = new Map<string, { 
  title?: string; 
  isLive: boolean 
}>();

export interface Streamer {
  id: string;
  platform: Platform;
  username: string;
  channelId: string;
  isLive: boolean;
  title?: string;
  viewers?: number;
  followers?: number;
  thumbnail?: string;
  profileImage?: string;
  lastLiveAt?: string;
  startedAt?: string;
  verified?: boolean;
  bio?: string;
}

export interface LiveStatus {
  platform: Platform;
  username: string;
  isLive: boolean;
  url: string;
  title?: string;
  viewers?: number;
  // ... more fields
}

export type Platform = 'kick' | 'twitch' | 'youtube' | 'rumble' | 'tiktok';

export interface Command {
  data: SlashCommandBuilder;
  execute: (interaction: ChatInputCommandInteraction) => Promise<void>;
}

export interface StreamerBotClient extends Client {
  commands: Collection<string, Command>;
  updateActivity(): void;
  startActivityRotation(intervalMs?: number): void;
  registerCommand(command: Command): void;
  getCommand(name: string): Command | undefined;
}

export const POLL_INTERVAL = 60 * 1000; // 60 seconds

logger.info("Message");
logger.error("Error", error);
logger.debug("Debug info");
logger.platform(platform, username, isLive);

npm run build  # Compiles src/ → dist/

dist/
├── index.js
├── client/
│   └── StreamerBot.js
├── commands/
├── services/
└── ...

DISCORD_TOKEN=your_discord_bot_token_here
NODE_ENV=production  # Optional
LOG_LEVEL=info       # Optional: debug, info, warn, error

{
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "build": "tsc",
    "start": "node dist/index.js",
    "deploy": "tsx scripts/deploy-commands.ts",
    "typecheck": "tsc --noEmit",
    "lint": "eslint src/"
  }
}