joe Télécharger - joe Téléchargement du code source

joe

Code Source AI

1.0.0

Télécharger

joe Bot ?

Une bibliothèque de robots à usage général inspirée de Hubot mais écrite en Go.

joe est une bibliothèque utilisée pour écrire des chatbots dans le langage de programmation Go. Il s'inspire beaucoup du formidable framework Hubot développé par les gens de Github et apporte sa puissance aux personnes qui souhaitent implémenter des chatbots à l'aide de Go.

Commencer

joe est une bibliothèque de logiciels conditionnée sous forme de module Go. Vous pouvez l'obtenir via :

joe ">

 go get github.com/go- joe / joe

Exemple d'utilisation

Vous pouvez trouver tous les exemples de code, plus d'explications et des recettes complètes sur https://joe-bot.net

Chaque bot se compose d'un adaptateur de chat (par exemple à intégrer à Slack), d'une implémentation de mémoire pour mémoriser les données clé-valeur (par exemple en utilisant Redis) et d'un cerveau qui achemine les nouveaux messages ou les événements personnalisés (par exemple la réception d'un appel HTTP) vers l'utilisateur enregistré correspondant. fonctions du gestionnaire .

Par défaut, joe .New(…) utilise l'adaptateur CLI qui permet au bot de lire les messages depuis stdin et de répondre sur stdout. De plus, le bot stockera les données de valeur clé en mémoire, ce qui signifie qu'il oubliera tout ce que vous lui avez dit au redémarrage. Cette configuration par défaut est utile pour le développement local sans aucune dépendance, mais vous souhaiterez rapidement ajouter d'autres modules pour étendre les capacités des robots.

L'exemple suivant connecte le Bot à un espace de travail Slack et stocke les données clé-valeur dans Redis. Pour permettre aux gestionnaires de messages d'accéder à la mémoire, nous les définissons comme des fonctions sur un type ExampleBot personnalisé qui intègre le 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
}

Modules disponibles

joe est livré sans modules tiers tels que l'intégration Redis pour éviter d'avoir plus de dépendances que ce dont vous avez réellement besoin. Il existe cependant déjà quelques modules que vous pouvez utiliser directement pour étendre les fonctionnalités de votre bot sans écrire trop de code vous-même.

Si vous avez écrit un module et souhaitez le partager, veuillez l'ajouter à cette liste et ouvrir une pull request.

Adaptateurs de discussion

Adaptateur Slack : https://github.com/go-joe/slack-adapter
Adaptateur Rocket.Chat : https://github.com/dwmunster/rocket-adapter
Adaptateur de télégramme : https://github.com/robertgzr/joe-telegram-adapter
Adaptateur IRC : https://github.com/akrennmair/joe-irc-adapter
Adaptateur Mattermost : https://github.com/dwmunster/joe-mattermost-adapter
Adaptateur VK : https://github.com/tdakkota/joe-vk-adapter

Modules de mémoire

Mémoire Redis : https://github.com/go-joe/redis-memory
Mémoire de fichiers : https://github.com/go-joe/file-memory
Mémoire de boulon : https://github.com/robertgzr/joe-bolt-memory
Mémoire SQLite : https://github.com/warmans/sqlite-memory

Autres modules

Serveur HTTP : https://github.com/go-joe/http-server
Emplois Cron : https://github.com/go-joe/cron

Construit avec

zap - Journalisation ultra rapide, structurée et nivelée dans Go
multierr - Le package multierr permet de combiner une ou plusieurs erreurs ensemble
testify - Une bibliothèque de tests unitaires simple

Contribuer

Veuillez lire CONTRIBUTING.md pour plus de détails sur notre code de conduite et sur le processus de soumission des demandes d'extraction à ce référentiel.

Gestion des versions

CE LOGICIEL EST TOUJOURS EN ALPHA ET IL N'EXISTE ENCORE AUCUNE GARANTIE CONCERNANT LA STABILITÉ DE L'API.

Tous les changements importants (par exemple, ruptures) sont documentés dans CHANGELOG.md.

Après la version v1.0, nous prévoyons d'utiliser SemVer pour la gestion des versions. Pour les versions disponibles, voir les balises sur ce référentiel.