joe

joe Bot?

Uma biblioteca de bots de uso geral inspirada no Hubot, mas escrita em Go.

---

joe é uma biblioteca usada para escrever bots de bate-papo na linguagem de programação Go. É muito inspirado na incrível estrutura Hubot desenvolvida pelo pessoal do Github e traz seu poder para pessoas que desejam implementar chatbots usando Go.

Começando

joe é uma biblioteca de software empacotada como módulo Go. Você pode obtê-lo através de:

joe ">

 go get github.com/go- joe / joe

Exemplo de uso

Você pode encontrar todos os exemplos de código, mais explicações e receitas completas em https://joe-bot.net

Cada bot consiste em um adaptador de bate-papo (por exemplo, para integração com o Slack), uma implementação de memória para lembrar dados de valor-chave (por exemplo, usando Redis) e um cérebro que roteia novas mensagens ou eventos personalizados (por exemplo, receber uma chamada HTTP) para o correspondente registrado. funções de manipulador .

Por padrão, joe .New(…) usa o adaptador CLI que faz com que o bot leia mensagens de stdin e responda em stdout. Além disso, o bot armazenará dados de valores-chave na memória, o que significa que esquecerá tudo o que você disse quando for reiniciado. Esta configuração padrão é útil para desenvolvimento local sem quaisquer dependências, mas você desejará adicionar rapidamente outros módulos para estender os recursos dos bots.

O exemplo a seguir conecta o Bot a um workspace do Slack e armazena dados de valor-chave no Redis. Para permitir que os manipuladores de mensagens acessem a memória, nós os definimos como funções em um tipo ExampleBot personalizado que incorpora o joe .Bot ​​.

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 }">

 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
}

Módulos disponíveis

joe não vem com módulos de terceiros, como integração com Redis, para evitar obter mais dependências do que você realmente precisa. No entanto, já existem alguns módulos que você pode usar diretamente para estender a funcionalidade do seu bot sem escrever muito código.

Se você escreveu um módulo e deseja compartilhá-lo, adicione-o a esta lista e abra uma solicitação pull.

Adaptadores de bate-papo

• Adaptador Slack: https://github.com/go-joe/slack-adapter
• Adaptador Rocket.Chat: https://github.com/dwmunster/rocket-adapter
• Adaptador de telegrama: https://github.com/robertgzr/joe-telegram-adapter
• Adaptador IRC: https://github.com/akrennmair/joe-irc-adapter
• Adaptador Mattermost: https://github.com/dwmunster/joe-mattermost-adapter
• Adaptador VK: https://github.com/tdakkota/joe-vk-adapter

Módulos de memória

• Memória Redis: https://github.com/go-joe/redis-memory
• Memória de arquivo: https://github.com/go-joe/file-memory
• Memória Bolt: https://github.com/robertgzr/joe-bolt-memory
• Memória SQLite: https://github.com/warmans/sqlite-memory

Outros Módulos

• Servidor HTTP: https://github.com/go-joe/http-server
• Cron Jobs: https://github.com/go-joe/cron

Construído com

• zap - Registro extremamente rápido, estruturado e nivelado em Go
• multierr - Pacote multierr permite combinar um ou mais erros juntos
• testificar – Uma biblioteca simples de testes de unidade

Contribuindo

Leia CONTRIBUTING.md para obter detalhes sobre nosso código de conduta e sobre o processo de envio de solicitações pull para este repositório.

Versionamento

ESTE SOFTWARE AINDA ESTÁ EM ALPHA E AINDA NÃO HÁ GARANTIAS RELATIVAS À ESTABILIDADE DA API.

Todas as alterações significativas (por exemplo, significativas) estão documentadas em CHANGELOG.md.

Após o lançamento v1.0, planejamos usar o SemVer para controle de versão. Para as versões disponíveis, consulte as tags neste repositório.

Autores

• Friedrich Große - Trabalho inicial - fgrosse

Veja também a lista de colaboradores que participaram deste projeto.

Licença

Este projeto está licenciado sob a licença BSD-3-Clause - consulte o arquivo LICENSE para obter detalhes.

Agradecimentos

• Hubot e sua grande comunidade pela inspiração
• embedmd para uma ferramenta interessante para incorporar código-fonte em arquivos markdown