Create commands for finding information about active club projects, such as associated roles, GitHub repositories, related tutorials, etc.

Feel free to recommend ideas for project-related commands in this thread!

Add a MVP set of commands for running polls.

Polls only support 1 question currently, though code has features for multi-question polls later. Each poll is assigned an integer id at creation. Polls are stored in-memory and erased at bot shutdown.

Adds 5 commands:

/startpoll

Creates a new poll. The poll starts "open", meaning it can be voted on.

Args:

• pollname: name of the poll
• question: string capturing the polls question
• choices: string capturing the question's choices delimited by |

/polls

Lists polls and their IDs, both closed and open. Closed polls have an asterisk to mark them as such.

/seepoll

View a poll. Shows name, question, options, and current votes for each option.

Args:

• pollid: ID of the poll (can be found with /polls)

/closepoll

Close a poll to stop new votes.

Args:

• pollid: ID of the poll (can be found with /polls)

/vote

Vote on a poll.

Args:

• pollid: ID of the poll (can be found with /polls)
• choices: Choices for each question of the poll, expressed as number (e.g. 1 means the first option). Support for multiple questions exists, by having numbers delimited by |. This is unused currently.

/giveRole Command

Create a slash command that allows server members to assign themselves a role. For example, /giveRole <role_name> will give the sender the role with name <role_name>. This command should allow users to give themselves only roles from an approved list of roles, the "permit list".

/openRole and /closeRole Commands

Create an admin-only slash command used to add roles to the "permit list": /openRole <role_name>. When an admin runs this command, it will "permit" the role with name <role_name> and make it possible for non-admin users to give themselves this role using /giveRole.

Create an admin-only slash command used to remove roles from the "permit list": /closeRole <role_name>. When an admin runs this command, it will "block" the role with name <role_name> and make it impossible for non-admin users to give themselves this role using /giveRole.

It would be ideal if the "permit list" was persistent across bot startups. This could be implemented with a small SQLite database, or even a basic read/write JSON file. (Bonus Feature: It would be great if a configuration file could provided via the command line when starting the bot to pre-populate the "permit list". Otherwise, the "permit list" will start empty).

/roles Command

Create a command to see what roles are on the "permit list", /roles. This should return a message indicating which roles are self-assignable with /giveRole.

User Story Example

For example, suppose the server has roles [role1, role2, moderator] where moderator is a server-specific privileged role. The admin will not want non-admin users be able to self-assign the moderator role. Then, the admin will run /openRole role1 and openRole role2 to permit users to self-assign these roles using /giveRole role1 or /giveRole role2.

Feel free to suggest modifications to these three role commands here, or open other issues for extensions to these commands elsewhere!

Add utilities to the code for logging information into a log file while the bot is deployed on the server.

The logs should offer several different levels of message severity. For example levels might include, in increasing severity:

• Debug
• Info
• Warning
• Error
• Critical

It would be best to accomplish this using a high-quality logging library offered through npm. A custom implementation will work if there isn't a suitable library available.

Once the logging utility is added, the other files in the code base should begin to incorporate it for event-driven logging.

Create commands for starting polls, voting in polls, stopping polls, viewing poll results, and seeing active polls

Polls have many potential variants: anonymous/caucus, timed/untimed, single vote/multiple vote, ranked choice, etc.

For these commands, the MVP is anonymous, single vote, multiple choice polls without automated timing. Users should be able to vote by DMing the bot a slash command to vote. This will make it anonymous.

/startPoll Command

Create a command which will initialize a new poll with a name, questions, and choices: /startPoll.

The exact argument structure is up to the implementer, but it should allow multiple questions in the poll, with a minimum of 1 question. Each question should have at least one available answer. Once the command is run successfully, the bot should reply with a message showing the name of the poll and its questions in readable format. The bot should also include a unique identifier in this response message; this could be accomplished by making the name unique or create a unique ID for each poll. The poll should be marked as "active" upon creation within the bot.

/stopPoll Command

Create a command which will stop an existing, active poll and prevent users from voting further: /stopPoll.

The argument structure is up to the implementer, but the command will need to take the poll's identifier. This command will mark a poll as inactive within the bot, and possibly make other changes to internally stored data as necessary. From the user perspective, this command will simply stop further voting on the poll permanently. The bot should reply with a confirmation that the poll was closed. Only the poll creator or an admin should be able to close a poll.

/vote Command

Create a command which will allow a user to vote in an existing poll: /vote.

This command should allow users to vote in a poll by passing the poll's identifier and their responses via command arguments in a DM to the bot. It would be ideal if the votes were stored anonymously. A conflicting, yet also desirable, feature would be allowing users to amend their votes. Methods to accomplish both likely exist, and might use some kind of hashing - feel free to suggest ideas in this thread. The bot should acknowledge the vote and repeat the responses back to the user.

/seePoll

Create a command which will allow users to see the results of a poll: /seePoll.

This command should allow users to see a poll's result by passing the poll's identifier. After receiving the command, the bot should reply with a response showing the tabulated results of the poll in an easily readable format. It might be best to offer a "verbose" argument which will make the bot provide a more in depth analysis of the results.

/polls

Create a command which will allow users to see active and inactive polls: /polls.

This command will reply with a readable list of all polls with their statuses: inactive or active. This is simply a way for users to see what polls are available to interact with.

Change how commands.ts loads all commands at runtime to be more readable and extensible.

Previously, commands.ts would load all commands by importing all modules under src/commands/ and assuming the default import from a module is the command. That is, any file in src/commands/ must adhere to the following strict structure where the default export must be a command:

const foo: ICommand  = {
    // code
}

export default foo;

This has two negative effects. First, this is not readable and makes the later import in the KV store in commands.ts non-obvious. Second, it is not extensible because it prevents files under src/commands/ from being able to export default items which are not commands and makes it impossible for a single file to export multiple commands. Either of these may be desirable in the future.

The proposed solution is to have files which offer commands to commands.ts export a function called getCommands. This name is standard across the code base. This solves the first issue by making the intended goal of the function explicit, and it solves the second by allowing variable default exports and multiple command exports.

It looks like this:

const foo: ICommand  = {
    // code
}

export function getCommand(): ICommand[] {
    return [foo];
}

A multiple command export could have a multi-item list in the return statement.

Currently, roles.ts assumes the presence of a role with name officer and gives this role privileged status. This could be an issue if other servers try to use the bot, or the bot is horizontally scaled to work on multiple servers.

Instead, a config variable should be added which stores the privileged role for the role management commands. The variable can be stored in config.json or another configuration file. Perhaps if the value is undefined, only the administrator role (which is server agnostic) is privileged.

Add a command which provides users with the hello world code for different programming languages.

Command Syntax: /helloworld [language]

Example: User runs /helloworld java Bot Responds:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

In animals.json, there are a lot of emoji that aren't particularly interesting to get from the lootbox. I think we should cut down on a lot of the dumb / uninteresting ones, and only keep the particularly interesting animals / food.

convert messages for commands into embeds for user.ts and server.ts discord.js embed docs: https://discordjs.guide/popular-topics/embeds.html#using-the-embed-constructor

Extend polling commands with more features and polish.

This includes:

• Timed Polls
• Single-vote Polls (enforce only 1 vote per discord user)
• Improved user interface for polls (both command structure and poll displays)
• Multi-question polls

We need to specify some stricter linting rules. There is no specific set of rules in mind, but any more comprehensive rule-set from the TypeScript development community would probably do.

We also need to add a npm run lint and npm run lint-fix command to the package.json. These should be:

"scripts": {
  // other commands. . .
  "lint": "eslint . --ext .ts,.tsx",
  "lint-fix": "eslint . --ext .ts,.tsx --fix"
 }

Lastly, we should add a PR workflow check which runs linting and blocks the PR till linting passes.

Write a command which grabs the top post off of a subreddit on Reddit. The initial version could just work for a particular subreddit if that's easier. Good candidates are r/programmerhumor or r/programming.

Command Syntax: /toppost [subreddit name]