main: Restructuring and cleanup

- Include (build/run).(bat/sh) scripts
- Add support for feature toggles
- Sync configuration on load to dispose of unused fields
- Update configuration template with non-nil values
- Add support for authenticating Wolfram|Alpha
- Add conversational query support, using Wolfram|Alpha only for now
- Split up command framework
- Move actual commands into subpackages of features (currently dumpctx and hellodolly, removing helloworld)
- Return command if name matches, not just alias list
- Stop attempting to support raw message commands for now
- Remove Discord metadata from command context
- Add service client interface to command context for service callbacks (not yet a custom interface type with methods)
- Support embed-style command responses
- Add ability for command to hold off on responding by being not ready (not yet reflected by Discord)
- Split up Discord framework
- Heavily revise Discord command handler to support nested subcommands
- Support Discord embeds with fields such as text, color, and image
- Remove display name and command prefix from Discord configuration
- Stop returning a Discord session when starting Discord, as the service is now stored internally within the package
- Add preliminary support for responding to message components
- Add go mod support
- Other specifics I didn't notice when reading the git diff

Author: JoshuaDoes

bot.go

@@ -6,16 +6,21 @@ import (
 	"os/signal"
 	"syscall"
 
-	"github.com/Clinet/clinet/discord"
+	"github.com/Clinet/clinet/cmds"
 	"github.com/Clinet/clinet/config"
+	"github.com/Clinet/clinet/convos"
+	"github.com/Clinet/clinet/discord"
+	"github.com/Clinet/clinet/features"
+	"github.com/Clinet/clinet/features/dumpctx"
+	"github.com/Clinet/clinet/features/hellodolly"
+	"github.com/JoshuaDoes/go-wolfram"
 )
 
 //Global error value because functions are mean
 var err error
 
 var (
-	cfg     *config.Config
-	Discord *discord.DiscordSession
+	cfg *config.Config
 )
 
 func doBot() {
@@ -29,22 +34,44 @@ func doBot() {
 		log.Error("Error loading configuration: ", err)
 	}
 
+	log.Info("Syncing configuration...")
+	cfg.SaveTo(configFile, config.ConfigTypeJSON)
+
 	if writeConfigTemplate {
 		log.Info("Updating configuration template...")
-		var templateCfg *config.Config = &config.Config{}
+		var templateCfg *config.Config = &config.Config{
+			Features: []*features.Feature{&features.Feature{Name: "example", Toggle: true}},
+			Discord: &discord.CfgDiscord{},
+			WolframAlpha: &wolfram.Client{},
+		}
 		templateCfg.SaveTo("config.template.json", config.ConfigTypeJSON)
 	}
 
+	log.Debug("Setting feature toggles...")
+	features.SetFeatures(cfg.Features)
+
+	log.Debug("Registering features...")
+	if features.IsEnabled("dumpctx") {
+		cmds.Commands = append(cmds.Commands, dumpctx.CmdRoot)
+	}
+	if features.IsEnabled("hellodolly") {
+		cmds.Commands = append(cmds.Commands, hellodolly.CmdRoot)
+	}
+
+	log.Debug("Enabling services...")
+	convos.AuthWolframAlpha(cfg.WolframAlpha)
+	log.Trace("- Wolfram|Alpha")
+
 	//Load modules
 	log.Info("Loading modules...")
 	loadModules()
 
 	//Start Discord
 	log.Info("Starting Discord...")
-	Discord = discord.StartDiscord(cfg.Discord)
-	defer Discord.Close()
+	discord.StartDiscord(cfg.Discord)
+	defer discord.Discord.Close()
 
-	log.Debug("Waiting for SIGINT syscall signal")
+	log.Debug("Waiting for SIGINT syscall signal...")
 	sc := make(chan os.Signal, 1)
 	signal.Notify(sc, syscall.SIGINT)
 	<-sc

build.bat

@@ -0,0 +1,5 @@
+@echo off
+:: Please use govvv when possible! (go install github.com/JoshuaDoes/govvv@latest)
+
+govvv build -ldflags="-s -w" -o clinet.exe
+:: go build -ldflags="-s -w" -o clinet.exe

build.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+# Please use govvv when possible! (go install github.com/JoshuaDoes/govvv@latest)
+
+govvv build -ldflags="-s -w" -o clinet.app
+## go build -ldflags="-s -w" -o clinet.app
+chmod +x clinet.app

cmds/arguments.go

@@ -0,0 +1,21 @@
+package cmds
+
+type CmdArg struct {
+	Name        string      //Display name for argument
+	Description string      //Description for command usage
+	Value       interface{} //Value for argument, set to default value (or zero value if required argument) when creating command
+	Required    bool        //True when argument must be changed
+}
+func NewCmdArg(name, desc string, value interface{}) *CmdArg {
+	return &CmdArg{
+		Name: name,
+		Description: desc,
+		Value: value,
+	}
+}
+func (arg *CmdArg) GetString() string {
+	return arg.Value.(string)
+}
+func (arg *CmdArg) SetRequired() {
+	arg.Required = true
+}

cmds/builder.go

@@ -0,0 +1,28 @@
+package cmds
+
+//CmdBuilder builds a list of Cmd paired to a CmdCtx
+type CmdBuilder struct {
+	Commands []*CmdBuilderCommand
+}
+func CmdBatch(cmds ...*CmdBuilderCommand) *CmdBuilder {
+	return &CmdBuilder{
+		Commands: cmds,
+	}
+}
+type CmdBuilderCommand struct {
+	Command *Cmd    //Command to execute
+	Context *CmdCtx //Context for command
+}
+func CmdBuildCommand(cmd *Cmd, ctx *CmdCtx) *CmdBuilderCommand {
+	return &CmdBuilderCommand{Command: cmd, Context: ctx}
+}
+func (cmdBuild *CmdBuilder) Run() ([]*CmdResp) {
+	if cmdBuild == nil || len(cmdBuild.Commands) == 0 {
+		return nil
+	}
+	resps := make([]*CmdResp, 0)
+	for _, command := range cmdBuild.Commands {
+		resps = append(resps, command.Command.Exec(command.Context))
+	}
+	return resps
+}

cmds/cmd-help.go

@@ -2,7 +2,7 @@ package cmds
 
 import (
 	"errors"
-	"strings"
+	"regexp"
 )
 
 var (
@@ -12,18 +12,15 @@ var (
 )
 
 //Commands holds the complete command list
-var Commands []*Cmd = []*Cmd{
-	&Cmd{
-		Handler: makeCmdRespHandler("Hello, world!"),
-		Matches: []string{"helloworld", "hw"},
-		Description: "Simply responds with a hello, world!",
-	},
-}
+var Commands []*Cmd = make([]*Cmd, 0)
 
 //GetCmd returns a cmd that matches the given alias
-func GetCmd(alias string) *Cmd {
+func GetCmd(match string) *Cmd {
 	for _, cmd := range Commands {
-		for _, match := range cmd.Matches {
+		if match == cmd.Name {
+			return cmd
+		}
+		for _, alias := range cmd.Aliases {
 			if match == alias {
 				return cmd
 			}
@@ -32,50 +29,49 @@ func GetCmd(alias string) *Cmd {
 	return nil
 }
 
-//CmdBuilder builds a list of Cmd paired to a CmdCtx
-type CmdBuilder struct {
-	Commands []*CmdBuilderCommand
+type Cmd struct {
+	Exec        func(*CmdCtx) *CmdResp //Go function to handle command
+	Name        string                 //Display name for command
+	Description string                 //Description for command lists and command usage
+	Aliases     []string               //Aliases to refer to command
+	Regexes     []regexp.Regexp        //Regular expressions to match command call with natural language ($1 is Args[0], $2 is Args[1], etc)
+	Args        []CmdArg               //Arguments for command
+	Subcommands []*Cmd                 //Subcommands for command (nestable, i.e. "/minecraft server mc.hypixel.net" where server is subcommand to minecraft command)
 }
-func CmdBatch(cmds ...*CmdBuilderCommand) *CmdBuilder {
-	return &CmdBuilder{
-		Commands: cmds,
+func NewCmd(name, desc string, handler func(*CmdCtx) *CmdResp) *Cmd {
+	return &Cmd{
+		Name: name,
+		Description: desc,
+		Aliases: []string{name},
+		Exec: handler,
 	}
 }
-type CmdBuilderCommand struct {
-	Command *Cmd    //Command to execute
-	Context *CmdCtx //Context for command
+func (cmd *Cmd) SetHandler(handler func(*CmdCtx) *CmdResp) {
+	cmd.Exec = handler
 }
-func CmdBuildCommand(cmd *Cmd, ctx *CmdCtx) *CmdBuilderCommand {
-	return &CmdBuilderCommand{Command: cmd, Context: ctx}
+func (cmd *Cmd) SetName(name string) {
+	cmd.Name = name
 }
-func (cmdBuild *CmdBuilder) Run() ([]*CmdResp) {
-	if cmdBuild == nil || len(cmdBuild.Commands) == 0 {
-		return nil
-	}
-	resps := make([]*CmdResp, 0)
-	for _, command := range cmdBuild.Commands {
-		resps = append(resps, command.Command.Exec(command.Context))
-	}
-	return resps
+func (cmd *Cmd) SetDescription(desc string) {
+	cmd.Description = desc
 }
-
-func CmdMessage(ctx *CmdCtx, content string) (*CmdBuilderCommand, error) {
-	//Build cmd
-	var cmd *Cmd = nil
-
-	raw := strings.Split(content, " ")
-	cmd = GetCmd(raw[0])
-	if cmd == nil {
-		return nil, ErrCmdNotFound
-	}
-
-	//Process ctx
-	ctx.CmdAlias = raw[0]
-	ctx.CmdParams = make([]string, 0)
-	if len(raw) > 1 {
-		ctx.CmdParams = raw[1:]
+func (cmd *Cmd) AddAliases(alias ...string) {
+	cmd.Aliases = append(cmd.Aliases, alias...)
+}
+func (cmd *Cmd) AddRegexes(regex ...regexp.Regexp) {
+	cmd.Regexes = append(cmd.Regexes, regex...)
+}
+func (cmd *Cmd) AddArgs(arg ...CmdArg) {
+	cmd.Args = append(cmd.Args, arg...)
+}
+func (cmd *Cmd) AddSubCmds(subCmd ...*Cmd) {
+	cmd.Subcommands = append(cmd.Subcommands, subCmd...)
+}
+func (cmd *Cmd) IsAlias(alias string) bool {
+	for i := 0; i < len(cmd.Aliases); i++ {
+		if cmd.Aliases[i] == alias {
+			return true
+		}
 	}
-
-	//Return cmd builder command
-	return CmdBuildCommand(cmd, ctx), nil
+	return false
 }

cmds/cmds.go

@@ -0,0 +1,49 @@
+package cmds
+
+import (
+	"github.com/JoshuaDoes/json"
+)
+
+type CmdCtx struct {
+	Content        string      //Raw message that triggered command
+	ContentDisplay string      //Displayable form of raw message
+	Alias          string      //Alias that triggered command
+	Args           []*CmdArg   //Arguments for command handler
+	Edited         bool        //True when called in response to edited call
+	Service        interface{} //Service client for service callbacks
+}
+func NewCmdCtx() *CmdCtx {
+	return &CmdCtx{}
+}
+func (ctx *CmdCtx) String() string {
+	jsonData, err := json.Marshal(ctx, true)
+	if err != nil {
+		return err.Error()
+	}
+	return string(jsonData)
+}
+func (ctx *CmdCtx) SetAlias(alias string) *CmdCtx {
+	ctx.Alias = alias
+	return ctx
+}
+func (ctx *CmdCtx) SetContent(content, contentDisplay string) *CmdCtx {
+	ctx.Content        = content        //<@!xxxxxxxxxx> Hello, world!
+	ctx.ContentDisplay = contentDisplay //@Clinet Hello, world!
+	return ctx
+}
+func (ctx *CmdCtx) SetQuery(alias string) *CmdCtx {
+	ctx.Alias  = alias  //helloworld
+	return ctx
+}
+func (ctx *CmdCtx) SetEdited() *CmdCtx {
+	ctx.Edited = true
+	return ctx
+}
+func (ctx *CmdCtx) SetService(service interface{}) *CmdCtx {
+	ctx.Service = service
+	return ctx
+}
+func (ctx *CmdCtx) AddArgs(arg ...*CmdArg) *CmdCtx {
+	ctx.Args = append(ctx.Args, arg...)
+	return ctx
+}