Joe Bot :robot:

A general-purpose bot library inspired by Hubot but written in Go.

Joe is a library used to write chat bots in the Go programming language. It is very much inspired by the awesome Hubot framework developed by the folks at Github and brings its power to people who want to implement chat bots using Go.

Getting Started

Joe is a software library that is packaged as Go module. You can get it via:

go get github.com/go-joe/joe

Example usage

You can find all code examples, more explanation and complete recipes at https://joe-bot.net

Each bot consists of a chat Adapter (e.g. to integrate with Slack), a Memory implementation to remember key-value data (e.g. using Redis) and a Brain which routes new messages or custom events (e.g. receiving an HTTP call) to the corresponding registered handler functions.

By default joe.New(…) uses the CLI adapter which makes the bot read messages from stdin and respond on stdout. Additionally the bot will store key value data in-memory which means it will forget anything you told it when it is restarted. This default setup is useful for local development without any dependencies but you will quickly want to add other Modules to extend the bots capabilities.

The following example connects the Bot with a Slack workspace and stores key-value data in Redis. To allow the message handlers to access the memory we define them as functions on a custom ExampleBottype which embeds the joe.Bot.

package main

import (
    "fmt"

    "github.com/go-joe/joe"
    "github.com/go-joe/redis-memory"
    "github.com/go-joe/slack-adapter/v2"
)

type ExampleBot struct {
    *joe.Bot
}

func main() {
    b := &ExampleBot{
        Bot: joe.New("example",
            redis.Memory("localhost:6379"),
            slack.Adapter("xoxb-1452345…"),
        ),
    }

    b.Respond("remember (.+) is (.+)", b.Remember)
    b.Respond("what is (.+)", b.WhatIs)

    err := b.Run()
    if err != nil {
        b.Logger.Fatal(err.Error())
    }
}

func (b *ExampleBot) Remember(msg joe.Message) error {
    key, value := msg.Matches[0], msg.Matches[1]
    msg.Respond("OK, I'll remember %s is %s", key, value)
    return b.Store.Set(key, value)
}

func (b *ExampleBot) WhatIs(msg joe.Message) error {
    key := msg.Matches[0]
    var value string
    ok, err := b.Store.Get(key, &value)
    if err != nil {
        return fmt.Errorf("failed to retrieve key %q from brain: %w", key, err)
    }

    if ok {
        msg.Respond("%s is %s", key, value)
    } else {
        msg.Respond("I do not remember %q", key)
    }

    return nil
}

Available modules

Joe ships with no third-party modules such as Redis integration to avoid pulling in more dependencies than you actually require. There are however already some modules that you can use directly to extend the functionality of your bot without writing too much code yourself.

If you have written a module and want to share it, please add it to this list and open a pull request.

Built With

zap - Blazing fast, structured, leveled logging in Go
multierr - Package multierr allows combining one or more errors together
testify - A simple unit test library

Contributing

Please read CONTRIBUTING.md for details on our code of conduct and on the process for submitting pull requests to this repository.

Versioning

THIS SOFTWARE IS STILL IN ALPHA AND THERE ARE NO GUARANTEES REGARDING API STABILITY YET.

All significant (e.g. breaking) changes are documented in the CHANGELOG.md.

After the v1.0 release we plan to use SemVer for versioning. For the versions available, see the tags on this repository.

Authors

Friedrich Große - Initial work - fgrosse

See also the list of contributors who participated in this project.

License

This project is licensed under the BSD-3-Clause License - see the LICENSE file for details.

Acknowledgments

Hubot and its great community for the inspiration
embedmd for a cool tool to embed source code in markdown files

go-joe / joe

readme