PepperBot Copilot Instructions

Repository Overview

PepperBot is a Discord bot built with TypeScript, Discord.js, and Bun. It features a command system with piping support, GPT integration, web interface, and extensive configuration options.

Code Style & Conventions

General Style

comments and log messages should be lowercase, no need to make everything so proper
avoid copy-pasted code - create reusable functions instead
use template strings with
```
${}
```
for string interpolation (preferred over concatenation)
prefer functional programming patterns where appropriate

DO NOT create .md files documenting changes. Do not create files like "CHANGES.md", "UPDATES.md", or any other documentation files explaining what has been modified. The git history and code itself show what has changed - additional documentation files are unnecessary and unwanted.

Logging Guidelines (import from

src/lib/log.ts

)

Log Levels and Usage:

```
log.info()
```
: generic info that can be made public. NEVER include private user data like usernames, channel names, or message content. IDs are perfectly fine and encouraged.
```
log.warn()
```
: warnings. avoid including user info.
```
log.error()
```
: errors. avoid including user info.
```
log.debug()
```
: private log level for debugging. message content & user data is okay since it won't be publicized. feel free to put as much data as you want here, it's only checked whenever i need to cross reference it for debugging purposes. having useful data here is heavily encouraged, i don't mind how much is logged since it doesn't show up most of the time. TLDR: feel free to be verbose.

Usage Examples:

log.info(`command executed successfully for user ${userId} in channel ${channelId}`);
log.debug(`processing message: "${message.content}" from ${message.author.username}`);
log.warn(`rate limit approaching for guild ${guildId}`);
log.error(`database connection failed: ${error.message}`);

Discord Bot Development

Commands

examine
```
src/lib/classes/command.ts
```
for available parameters and types
look at existing commands in
```
src/commands/
```
for implementation patterns
use the
```
Command
```
class constructor with proper typing for all parameters
implement
```
getArgumentsTemplate()
```
for argument parsing
commands should return
```
CommandResponse
```
objects for proper piping support

Command Structure Example:

const command = new Command(
    {
        name: 'commandname',
        description: 'short description',
        long_description: 'detailed description with examples',
        tags: [CommandTag.Utility],
        options: [/* CommandOption objects */],
        access: CommandAccessTemplates.public,
        input_types: [InvokerType.Message],
        example_usage: "p/commandname example"
    },
    getArgumentsTemplate(/* template type and args */),
    async function execute({ invoker, args, guild_config, piped_data, will_be_piped }) {
        // implementation
        return new CommandResponse({ /* response data */ });
    }
);

you can also take a look at the vscode snippets at

.vscode/custom.code-snippets

for even more information on how to write commands.

Event Handlers

located in
```
src/events/
```
follow Discord.js event patterns
use proper error handling and logging

Web Interface Development

Technology Stack

Express.js with Handlebars templating
Individual stylesheets per page + shared main stylesheet
TypeScript for page scripts

File Organization

Views:
```
views/
```
- Handlebars templates (.handlebars)
Styles:
```
public/styles/
```
- CSS files, one per page + main.css
Scripts:
```
src/web/pages/
```
- TypeScript page logic
Layouts:
```
views/layouts/
```
- Handlebars layout templates
Partials:
```
views/partials/
```
- Reusable Handlebars components

Style Guidelines

each page imports from
```
main.css
```
for base styles
use consistent class naming (e.g.,
```
card
```
,
```
spinny-button
```
,
```
side-padding
```
)
follow existing UI patterns (flex layouts, spacing classes)
maintain responsive design principles

Handlebars Development

use semantic HTML structure
leverage partials for reusable components
pass data efficiently from Express routes
follow existing naming conventions for CSS classes

Database & Data Management

uses Knex.js for database operations
migration files in
```
migrations/
```
database utilities in
```
src/lib/data_manager.ts
```
follow existing patterns for model classes (see
```
src/lib/alias_manager.ts
```
, or any other "manager" script)

Configuration & Environment

guild-specific configurations in
```
src/lib/guild_config_manager.ts
```
environment variables managed through
```
.env
```
use
```
bun
```
for package management and running scripts

Testing & Development

Important: Testing Restrictions

DO NOT use bun to test if changes work. While bun is used for package installation, don't use it to run tests. it's extremely annoying and will not help you in this case. if you want to test changes, ask me to and i will test shit for you.

Package Management

use
```
bun install
```
for dependencies

File Structure Patterns

Commands:
```
src/commands/[command-name].ts
```
Events:
```
src/events/[event-name].ts
```
Libraries:
```
src/lib/[functionality].ts
```
Web Pages:
```
src/web/pages/[page-name].ts
```
Utilities:
```
src/lib/classes/
```
for shared classes
Constants:
```
constants/
```
for static data

Security & Privacy

be mindful of what data gets logged at different log levels
user privacy is important - keep sensitive data out of public logs
validate inputs properly, especially for web interfaces

Dependencies & Libraries

Discord.js for Discord API
Express + Handlebars for web interface
Knex for database operations
Sharp for image processing
OpenAI/Ollama for GPT functionality
Various utility libraries (see package.json)

Debugging & Maintenance

extensive logging system with multiple levels
web interface for viewing logs and statistics
database migration system for schema changes
comprehensive error handling throughout the codebase