v0.2.0

laniakea/bot.go

@@ -0,0 +1,560 @@
+package laniakea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/redis/go-redis/v9"
+	"github.com/vinovest/sqlx"
+	"go.mongodb.org/mongo-driver/v2/mongo"
+)
+
+type ParseMode string
+
+const (
+	ParseMDV2 ParseMode = "MarkdownV2"
+	ParseHTML ParseMode = "HTML"
+	ParseMD   ParseMode = "Markdown"
+)
+
+type Bot struct {
+	token         string
+	debug         bool
+	errorTemplate string
+
+	logger        *Logger
+	requestLogger *Logger
+
+	plugins     []*Plugin
+	middlewares []*Middleware
+	prefixes    []string
+
+	dbContext *DatabaseContext
+
+	updateOffset int
+	updateTypes  []string
+	updateQueue  *Queue[*Update]
+}
+
+type BotSettings struct {
+	Token            string
+	Debug            bool
+	ErrorTemplate    string
+	Prefixes         []string
+	UpdateTypes      []string
+	LoggerBasePath   string
+	UseRequestLogger bool
+	WriteToFile      bool
+}
+
+func LoadSettingsFromEnv() *BotSettings {
+	return &BotSettings{
+		Token:            os.Getenv("TG_TOKEN"),
+		Debug:            os.Getenv("DEBUG") == "true",
+		ErrorTemplate:    os.Getenv("ERROR_TEMPLATE"),
+		Prefixes:         LoadPrefixesFromEnv(),
+		UpdateTypes:      strings.Split(os.Getenv("UPDATE_TYPES"), ";"),
+		UseRequestLogger: os.Getenv("USE_REQ_LOG") == "true",
+		WriteToFile:      os.Getenv("WRITE_TO_FILE") == "true",
+	}
+}
+
+type MsgContext struct {
+	Bot           *Bot
+	Msg           *Message
+	Update        *Update
+	From          *User
+	CallbackMsgId int
+	FromID        int
+	Prefix        string
+	Text          string
+	Args          []string
+}
+
+type DatabaseContext struct {
+	PostgresSQL *sqlx.DB
+	MongoDB     *mongo.Client
+	Redis       *redis.Client
+}
+
+func NewBot(settings *BotSettings) *Bot {
+	updateQueue := CreateQueue[*Update](256)
+	bot := &Bot{
+		updateOffset: 0, plugins: make([]*Plugin, 0), debug: settings.Debug, errorTemplate: "%s",
+		prefixes: settings.Prefixes, updateTypes: make([]string, 0),
+		updateQueue: updateQueue,
+		token:       settings.Token,
+	}
+
+	if len(settings.ErrorTemplate) > 0 {
+		bot.errorTemplate = settings.ErrorTemplate
+	}
+
+	if len(settings.LoggerBasePath) == 0 {
+		settings.LoggerBasePath = "./"
+	}
+	level := FATAL
+	if settings.Debug {
+		level = DEBUG
+	}
+
+	bot.logger = CreateLogger().Level(level).PrintTraceback(true)
+	bot.logger.AddWriter(bot.logger.CreateStdoutWriter())
+	if settings.WriteToFile {
+		path := fmt.Sprintf("%s/main.log", strings.TrimRight(settings.LoggerBasePath, "/"))
+		fileWriter, err := bot.logger.CreateFileWriter(path)
+		if err != nil {
+			bot.logger.Fatal(err)
+		}
+		bot.logger.AddWriter(fileWriter)
+	}
+
+	if settings.UseRequestLogger {
+		bot.requestLogger = CreateLogger().Level(level).Prefix("REQUESTS")
+		bot.requestLogger.AddWriter(bot.requestLogger.CreateStdoutWriter())
+		if settings.WriteToFile {
+			path := fmt.Sprintf("%s/requests.log", strings.TrimRight(settings.LoggerBasePath, "/"))
+			fileWriter, err := bot.requestLogger.CreateFileWriter(path)
+			if err != nil {
+				bot.logger.Fatal(err)
+			}
+			bot.requestLogger.AddWriter(fileWriter)
+		}
+	}
+
+	return bot
+}
+
+func (b *Bot) Close() {
+	for _, writer := range b.logger.writers {
+		err := writer.Close()
+		if err != nil {
+			log.Println(err)
+		}
+	}
+}
+
+func (b *Bot) InitDatabaseContext(ctx *DatabaseContext) *Bot {
+	b.dbContext = ctx
+	return b
+}
+func (b *Bot) AddDatabaseLogger(writer func(db *DatabaseContext) *LoggerWriter) *Bot {
+	w := writer(b.dbContext)
+	b.logger.AddWriter(w)
+	if b.requestLogger != nil {
+		b.requestLogger.AddWriter(w)
+	}
+	return b
+}
+
+func (b *Bot) UpdateTypes(t ...string) *Bot {
+	b.updateTypes = make([]string, 0)
+	b.updateTypes = append(b.updateTypes, t...)
+	return b
+}
+func (b *Bot) AddUpdateType(t ...string) *Bot {
+	b.updateTypes = append(b.updateTypes, t...)
+	return b
+}
+
+func (b *Bot) AddPrefixes(prefixes ...string) *Bot {
+	b.prefixes = append(b.prefixes, prefixes...)
+	return b
+}
+
+func LoadPrefixesFromEnv() []string {
+	prefixesS, exists := os.LookupEnv("PREFIXES")
+	if !exists {
+		return []string{"!"}
+	}
+	return strings.Split(prefixesS, ";")
+}
+
+func (b *Bot) ErrorTemplate(s string) *Bot {
+	b.errorTemplate = s
+	return b
+}
+
+func (b *Bot) Debug(debug bool) *Bot {
+	b.debug = debug
+	return b
+}
+
+func (b *Bot) AddPlugins(plugin ...*Plugin) *Bot {
+	b.plugins = append(b.plugins, plugin...)
+	for _, p := range plugin {
+		b.logger.Debug(fmt.Sprintf("plugins with name \"%s\" registered", p.Name))
+	}
+	return b
+}
+
+func (b *Bot) AddMiddleware(middleware ...*Middleware) *Bot {
+	sort.Slice(middleware, func(a, b int) bool {
+		first := middleware[a]
+		second := middleware[b]
+		if first.Order == second.Order {
+			return first.Name < second.Name
+		}
+		return middleware[a].Order < middleware[b].Order
+	})
+
+	b.middlewares = append(b.middlewares, middleware...)
+	for _, m := range middleware {
+		b.logger.Debug(fmt.Sprintf("middleware with name \"%s\" registered", m.Name))
+	}
+	return b
+}
+
+func (b *Bot) Run() {
+	if len(b.prefixes) == 0 {
+		b.logger.Fatal("no prefixes defined")
+		return
+	}
+
+	if len(b.plugins) == 0 {
+		b.logger.Fatal("no plugins defined")
+		return
+	}
+
+	b.logger.Info("Bot running. Press CTRL+C to exit.")
+
+	go func() {
+		for {
+			_, err := b.Updates()
+			if err != nil {
+				b.logger.Error(err)
+			}
+			time.Sleep(time.Millisecond * 10)
+		}
+	}()
+
+	for {
+		queue := b.updateQueue
+		if queue.IsEmpty() {
+			time.Sleep(time.Millisecond * 25)
+			continue
+		}
+
+		u := queue.Dequeue()
+		if u == nil {
+			b.logger.Error("update is nil")
+			continue
+		}
+		ctx := &MsgContext{
+			Bot:    b,
+			Update: u,
+		}
+		for _, middleware := range b.middlewares {
+			middleware.Execute(ctx, b.dbContext)
+		}
+
+		for _, plugin := range b.plugins {
+			if plugin.UpdateListener != nil {
+				(*plugin.UpdateListener)(ctx, b.dbContext)
+			}
+		}
+
+		if u.CallbackQuery != nil {
+			b.handleCallback(u, ctx)
+		} else {
+			b.handleMessage(u, ctx)
+		}
+	}
+}
+
+// {"callback_query":{"chat_instance":"6202057960757700762","data":"aboba","from":{"first_name":"scuroneko","id":314834933,"is_bot":false,"language_code":"ru","username":"scuroneko"},"id":"1352205741990111553","message":{"chat":{"first_name":"scuroneko","id":314834933,"type":"private","username":"scuroneko"},"date":1734338107,"from":{"first_name":"Kurumi","id":7718900880,"is_bot":true,"username":"kurumi_game_bot"},"message_id":19,"reply_markup":{"inline_keyboard":[[{"callback_data":"aboba","text":"Test"},{"callback_data":"another","text":"Another"}]]},"text":"Aboba"}},"update_id":350979488}
+
+func (b *Bot) handleMessage(update *Update, ctx *MsgContext) {
+	var text string
+	if update.Message == nil {
+		return
+	}
+	if len(update.Message.Text) > 0 {
+		text = update.Message.Text
+	} else {
+		text = update.Message.Caption
+	}
+
+	ctx.FromID = update.Message.From.ID
+	ctx.From = update.Message.From
+	ctx.Msg = update.Message
+	text = strings.TrimSpace(text)
+	prefix, hasPrefix := b.checkPrefixes(text)
+	if !hasPrefix {
+		return
+	}
+	ctx.Prefix = prefix
+
+	text = strings.TrimSpace(text[len(prefix):])
+
+	for _, plugin := range b.plugins {
+		// Check every command
+		for cmd := range plugin.Commands {
+			if !strings.HasPrefix(text, cmd) {
+				continue
+			}
+
+			ctx.Text = strings.TrimSpace(text[len(cmd):])
+			ctx.Args = strings.Split(ctx.Text, " ")
+
+			go plugin.Execute(cmd, ctx, b.dbContext)
+		}
+	}
+}
+
+func (b *Bot) handleCallback(update *Update, ctx *MsgContext) {
+	data := new(CallbackData)
+	err := json.Unmarshal([]byte(update.CallbackQuery.Data), data)
+	if err != nil {
+		b.logger.Error(err)
+		return
+	}
+
+	ctx.FromID = update.CallbackQuery.From.ID
+	ctx.From = update.CallbackQuery.From
+	ctx.Msg = update.CallbackQuery.Message
+	ctx.CallbackMsgId = update.CallbackQuery.Message.MessageID
+	ctx.Args = data.Args
+
+	for _, plugin := range b.plugins {
+		_, ok := plugin.Payloads[data.Command]
+		if !ok {
+			continue
+		}
+		go plugin.ExecutePayload(data.Command, ctx, b.dbContext)
+		break
+	}
+}
+
+func (b *Bot) checkPrefixes(text string) (string, bool) {
+	for _, prefix := range b.prefixes {
+		if strings.HasPrefix(text, prefix) {
+			return prefix, true
+		}
+	}
+	return "", false
+}
+
+type AnswerMessage struct {
+	MessageID int
+	Text      string
+	IsMedia   bool
+	Keyboard  *InlineKeyboard
+	ctx       *MsgContext
+}
+
+func (ctx *MsgContext) edit(messageId int, text string, keyboard *InlineKeyboard) *AnswerMessage {
+	params := &EditMessageTextP{
+		MessageID: messageId,
+		ChatID:    ctx.Msg.Chat.ID,
+		Text:      text,
+		ParseMode: ParseMD,
+	}
+	if keyboard != nil {
+		params.ReplyMarkup = keyboard.Get()
+	}
+	msg, err := ctx.Bot.EditMessageText(params)
+	if err != nil {
+		ctx.Bot.logger.Error(err)
+		return nil
+	}
+	return &AnswerMessage{
+		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: false,
+	}
+}
+func (m *AnswerMessage) Edit(text string) *AnswerMessage {
+	return m.ctx.edit(m.MessageID, text, nil)
+}
+func (ctx *MsgContext) EditCallback(text string, keyboard *InlineKeyboard) *AnswerMessage {
+	if ctx.CallbackMsgId == 0 {
+		ctx.Bot.logger.Error("Can't edit non-callback update message")
+		return nil
+	}
+
+	return ctx.edit(ctx.CallbackMsgId, text, keyboard)
+}
+func (ctx *MsgContext) EditCallbackf(format string, keyboard *InlineKeyboard, args ...any) *AnswerMessage {
+	return ctx.EditCallback(fmt.Sprintf(format, args...), keyboard)
+}
+
+func (ctx *MsgContext) editPhotoText(messageId int, text string, kb *InlineKeyboard) *AnswerMessage {
+	params := &EditMessageCaptionP{
+		ChatID:    ctx.Msg.Chat.ID,
+		MessageID: messageId,
+		Caption:   text,
+		ParseMode: ParseMD,
+	}
+	if kb != nil {
+		params.ReplyMarkup = kb.Get()
+	}
+	msg, err := ctx.Bot.EditMessageCaption(params)
+	if err != nil {
+		ctx.Bot.logger.Error(err)
+	}
+	return &AnswerMessage{
+		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: true,
+	}
+}
+func (m *AnswerMessage) EditCaption(text string) *AnswerMessage {
+	return m.ctx.editPhotoText(m.MessageID, text, nil)
+}
+func (m *AnswerMessage) EditCaptionKeyboard(text string, kb *InlineKeyboard) *AnswerMessage {
+	return m.ctx.editPhotoText(m.MessageID, text, kb)
+}
+
+func (ctx *MsgContext) answer(text string, keyboard *InlineKeyboard) *AnswerMessage {
+	params := &SendMessageP{
+		ChatID:    ctx.Msg.Chat.ID,
+		Text:      text,
+		ParseMode: ParseMD,
+	}
+	if keyboard != nil {
+		params.ReplyMarkup = keyboard.Get()
+	}
+
+	msg, err := ctx.Bot.SendMessage(params)
+	if err != nil {
+		ctx.Bot.logger.Error(err)
+		return nil
+	}
+	return &AnswerMessage{
+		MessageID: msg.MessageID, ctx: ctx, IsMedia: false, Text: text,
+	}
+}
+func (ctx *MsgContext) Answer(text string) *AnswerMessage {
+	return ctx.answer(text, nil)
+}
+func (ctx *MsgContext) Answerf(template string, args ...any) *AnswerMessage {
+	return ctx.answer(fmt.Sprintf(template, args...), nil)
+}
+func (ctx *MsgContext) Keyboard(text string, kb *InlineKeyboard) *AnswerMessage {
+	return ctx.answer(text, kb)
+}
+
+func (ctx *MsgContext) answerPhoto(photoId, text string, kb *InlineKeyboard) *AnswerMessage {
+	params := &SendPhotoP{
+		ChatID:    ctx.Msg.Chat.ID,
+		Caption:   text,
+		Photo:     photoId,
+		ParseMode: ParseMD,
+	}
+	if kb != nil {
+		params.ReplyMarkup = kb.Get()
+	}
+	msg, err := ctx.Bot.SendPhoto(params)
+	if err != nil {
+		ctx.Bot.logger.Error(err)
+	}
+	return &AnswerMessage{
+		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: true,
+	}
+}
+func (ctx *MsgContext) AnswerPhoto(photoId, text string) *AnswerMessage {
+	return ctx.answerPhoto(photoId, text, nil)
+}
+func (ctx *MsgContext) AnswerPhotoKeyboard(photoId, text string, kb *InlineKeyboard) *AnswerMessage {
+	return ctx.answerPhoto(photoId, text, kb)
+}
+
+func (ctx *MsgContext) delete(messageId int) {
+	_, err := ctx.Bot.DeleteMessage(&DeleteMessageP{
+		ChatID:    ctx.Msg.Chat.ID,
+		MessageID: messageId,
+	})
+	if err != nil {
+		ctx.Bot.logger.Error(err)
+	}
+}
+func (m *AnswerMessage) Delete() {
+	m.ctx.delete(m.MessageID)
+}
+func (ctx *MsgContext) CallbackDelete() {
+	ctx.delete(ctx.CallbackMsgId)
+}
+
+func (ctx *MsgContext) Error(err error) {
+	_, sendErr := ctx.Bot.SendMessage(&SendMessageP{
+		ChatID: ctx.Msg.Chat.ID,
+		Text:   fmt.Sprintf(ctx.Bot.errorTemplate, EscapeMarkdown(err.Error())),
+	})
+	ctx.Bot.logger.Error(err)
+
+	if sendErr != nil {
+		ctx.Bot.logger.Error(sendErr)
+	}
+}
+
+func (b *Bot) Logger() *Logger {
+	return b.logger
+}
+
+type ApiResponse struct {
+	Ok          bool           `json:"ok"`
+	Result      map[string]any `json:"result,omitempty"`
+	Description string         `json:"description,omitempty"`
+	ErrorCode   int            `json:"error_code,omitempty"`
+}
+
+type ApiResponseA struct {
+	Ok          bool   `json:"ok"`
+	Result      []any  `json:"result,omitempty"`
+	Description string `json:"description,omitempty"`
+	ErrorCode   int    `json:"error_code,omitempty"`
+}
+
+// request is a low-level call to api.
+func (b *Bot) request(methodName string, params any) (map[string]interface{}, error) {
+	var buf bytes.Buffer
+	err := json.NewEncoder(&buf).Encode(params)
+	if err != nil {
+		return nil, err
+	}
+
+	if b.debug && b.requestLogger != nil {
+		b.requestLogger.Debug(strings.ReplaceAll(fmt.Sprintf(
+			"POST https://api.telegram.org/bot%s/%s %s",
+			"<TOKEN>",
+			methodName,
+			buf.String(),
+		), "\n", ""))
+	}
+	r, err := http.Post(fmt.Sprintf("https://api.telegram.org/bot%s/%s", b.token, methodName), "application/json", &buf)
+	if err != nil {
+		return nil, err
+	}
+	defer r.Body.Close()
+	data, err := io.ReadAll(r.Body)
+	if err != nil {
+		return nil, err
+	}
+	b.requestLogger.Debug(fmt.Sprintf("RES %s %s", methodName, string(data)))
+	response := new(ApiResponse)
+
+	var result map[string]any
+
+	err = json.Unmarshal(data, &response)
+	if err != nil {
+		responseArray := new(ApiResponseA)
+		err = json.Unmarshal(data, responseArray)
+		if err != nil {
+			return nil, err
+		}
+		result = map[string]interface{}{
+			"data": responseArray.Result,
+		}
+	} else {
+		result = response.Result
+	}
+	if !response.Ok {
+		return nil, fmt.Errorf("[%d] %s", response.ErrorCode, response.Description)
+	}
+	return result, err
+}

laniakea/keyboard.go

@@ -0,0 +1,74 @@
+package laniakea
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type InlineKeyboard struct {
+	CurrentLine []InlineKeyboardButton
+	Lines       [][]InlineKeyboardButton
+	maxRow      int
+}
+
+func NewInlineKeyboard(maxRow int) *InlineKeyboard {
+	return &InlineKeyboard{
+		CurrentLine: make([]InlineKeyboardButton, 0),
+		Lines:       make([][]InlineKeyboardButton, 0),
+		maxRow:      maxRow,
+	}
+}
+
+func (in *InlineKeyboard) append(button InlineKeyboardButton) *InlineKeyboard {
+	if len(in.CurrentLine) == in.maxRow {
+		in.AddLine()
+	}
+	in.CurrentLine = append(in.CurrentLine, button)
+	return in
+}
+func (in *InlineKeyboard) AddUrlButton(text, url string) *InlineKeyboard {
+	return in.append(InlineKeyboardButton{Text: text, URL: url})
+}
+func (in *InlineKeyboard) AddCallbackButton(text string, cmd string, args ...any) *InlineKeyboard {
+	return in.append(InlineKeyboardButton{Text: text, CallbackData: NewCallbackData(cmd, args...).ToJson()})
+}
+
+func (in *InlineKeyboard) AddLine() *InlineKeyboard {
+	if len(in.CurrentLine) == 0 {
+		return in
+	}
+	in.Lines = append(in.Lines, in.CurrentLine)
+	in.CurrentLine = make([]InlineKeyboardButton, 0)
+	return in
+}
+func (in *InlineKeyboard) Get() InlineKeyboardMarkup {
+	if len(in.CurrentLine) > 0 {
+		in.Lines = append(in.Lines, in.CurrentLine)
+	}
+	return InlineKeyboardMarkup{
+		InlineKeyboard: in.Lines,
+	}
+}
+
+type CallbackData struct {
+	Command string   `json:"cmd"`
+	Args    []string `json:"args"`
+}
+
+func NewCallbackData(command string, args ...any) *CallbackData {
+	stringArgs := make([]string, len(args))
+	for i, arg := range args {
+		stringArgs[i] = fmt.Sprint(arg)
+	}
+	return &CallbackData{
+		Command: command,
+		Args:    stringArgs,
+	}
+}
+func (d *CallbackData) ToJson() string {
+	data, err := json.Marshal(d)
+	if err != nil {
+		return `{"cmd":""}`
+	}
+	return string(data)
+}

laniakea/logger.go

@@ -0,0 +1,259 @@
+package laniakea
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/fatih/color"
+)
+
+type LoggerWriter struct {
+	writer  io.Writer
+	writeFn LoggerWriterFn
+	logger  *Logger
+}
+
+func (w *LoggerWriter) SetFn(fn LoggerWriterFn) {
+	w.writeFn = fn
+}
+func (w *LoggerWriter) Write(p []byte) (n int, err error) {
+	return w.writer.Write(p)
+}
+func (w *LoggerWriter) Close() error {
+	return w.writer.(io.Closer).Close()
+}
+
+type LoggerWriterFn func(level LogLevel, prefix, traceback string, message []any) error
+
+type Logger struct {
+	prefix         string
+	level          LogLevel
+	printTraceback bool
+	printTime      bool
+	writers        []*LoggerWriter
+}
+
+type LogLevel struct {
+	n uint8
+	t string
+	c color.Attribute
+}
+
+func (l *LogLevel) GetName() string {
+	return l.t
+}
+
+type MethodTraceback struct {
+	Package   string
+	Method    string
+	fullPath  string
+	signature string
+	filename  string
+	line      int
+}
+
+var (
+	INFO  = LogLevel{n: 0, t: "info", c: color.FgWhite}
+	WARN  = LogLevel{n: 1, t: "warn", c: color.FgHiYellow}
+	ERROR = LogLevel{n: 2, t: "error", c: color.FgHiRed}
+	FATAL = LogLevel{n: 3, t: "fatal", c: color.FgRed}
+	DEBUG = LogLevel{n: 4, t: "debug", c: color.FgGreen}
+)
+
+func CreateLogger() *Logger {
+	return &Logger{
+		prefix:         "LOG",
+		level:          FATAL,
+		printTraceback: false,
+		printTime:      true,
+	}
+}
+
+func (l *Logger) CreateFileWriter(path string) (*LoggerWriter, error) {
+	err := os.MkdirAll(filepath.Dir(path), os.ModePerm)
+	if err != nil {
+		return nil, err
+	}
+	file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return nil, err
+	}
+
+	writer := &LoggerWriter{
+		writer: file, logger: l,
+	}
+	writer.writeFn = func(level LogLevel, prefix, traceback string, message []any) error {
+		_, err = writer.Write([]byte(writer.logger.buildString(level, message) + "\n"))
+		return err
+	}
+	return writer, nil
+}
+func (l *Logger) CreateStdoutWriter() *LoggerWriter {
+	writer := &LoggerWriter{
+		writer: os.Stdout, logger: l,
+	}
+	writer.writeFn = func(level LogLevel, prefix, traceback string, message []any) error {
+		_, err := color.New(level.c).Fprint(writer.writer, writer.logger.buildString(level, message))
+		return err
+	}
+	return writer
+}
+
+func (l *Logger) Prefix(prefix string) *Logger {
+	l.prefix = prefix
+	return l
+}
+func (l *Logger) Level(level LogLevel) *Logger {
+	l.level = level
+	return l
+}
+func (l *Logger) PrintTraceback(b bool) *Logger {
+	l.printTraceback = b
+	return l
+}
+func (l *Logger) PrintTime(b bool) *Logger {
+	l.printTime = b
+	return l
+}
+func (l *Logger) AddWriters(writers ...*LoggerWriter) *Logger {
+	l.writers = append(l.writers, writers...)
+	return l
+}
+func (l *Logger) AddWriter(writer *LoggerWriter) *Logger {
+	l.writers = append(l.writers, writer)
+	return l
+}
+
+func (l *Logger) Infof(format string, m ...any) {
+	l.print(INFO, []any{fmt.Sprintf(format, m...)})
+}
+func (l *Logger) Info(m ...any) {
+	l.print(INFO, m)
+}
+
+func (l *Logger) Warn(m ...any) {
+	l.print(WARN, m)
+}
+
+func (l *Logger) Error(m ...any) {
+	l.print(ERROR, m)
+}
+
+func (l *Logger) Fatal(m ...any) {
+	l.print(FATAL, m)
+	os.Exit(1)
+}
+
+func (l *Logger) Debug(m ...any) {
+	l.print(DEBUG, m)
+}
+
+func (l *Logger) formatTime(t time.Time) string {
+	return fmt.Sprintf("%02d.%02d.%02d %02d:%02d:%02d", t.Day(), t.Month(), t.Year(), t.Hour(), t.Minute(), t.Second())
+}
+
+func (l *Logger) getTraceback() *MethodTraceback {
+	caller, _, _, _ := runtime.Caller(4)
+	details := runtime.FuncForPC(caller)
+	signature := details.Name()
+	path, line := details.FileLine(caller)
+	splitPath := strings.Split(path, "/")
+
+	splitSignature := strings.Split(signature, ".")
+	pkg, method := splitSignature[0], splitSignature[len(splitSignature)-1]
+
+	tb := &MethodTraceback{
+		filename:  splitPath[len(splitPath)-1],
+		fullPath:  path,
+		line:      line,
+		signature: signature,
+		Package:   pkg,
+		Method:    method,
+	}
+
+	return tb
+}
+func (l *Logger) formatTraceback(mt *MethodTraceback) string {
+	return fmt.Sprintf("%s:%s:%d", mt.filename, mt.Method, mt.line)
+}
+
+func (l *Logger) getFullTraceback(skip int) []*MethodTraceback {
+	pc := make([]uintptr, 15)
+	runtime.Callers(skip, pc)
+	list := make([]*MethodTraceback, 0)
+	frames := runtime.CallersFrames(pc)
+	for {
+		frame, more := frames.Next()
+		if !more {
+			break
+		}
+		details := runtime.FuncForPC(frame.PC)
+		signature := details.Name()
+		path, line := details.FileLine(frame.PC)
+		splitPath := strings.Split(path, "/")
+
+		splitSignature := strings.Split(signature, ".")
+		pkg, method := splitSignature[0], splitSignature[len(splitSignature)-1]
+
+		tb := &MethodTraceback{
+			filename:  splitPath[len(splitPath)-1],
+			fullPath:  path,
+			line:      line,
+			signature: signature,
+			Package:   pkg,
+			Method:    method,
+		}
+		list = append(list, tb)
+	}
+	sort.Slice(list, func(i, j int) bool {
+		return j < i
+	})
+	return list
+}
+func (l *Logger) formatFullTraceback(tracebacks []*MethodTraceback) string {
+	formatted := make([]string, 0)
+	for _, tb := range tracebacks {
+		formatted = append(formatted, l.formatTraceback(tb))
+	}
+	return strings.Join(formatted, "->")
+}
+
+func (l *Logger) buildString(level LogLevel, m []any) string {
+	args := []string{
+		fmt.Sprintf("[%s]", l.prefix),
+		fmt.Sprintf("[%s]", strings.ToUpper(level.t)),
+	}
+
+	if l.printTraceback {
+		args = append(args, fmt.Sprintf("[%s]", l.formatTraceback(l.getTraceback())))
+	}
+
+	if l.printTime {
+		args = append(args, fmt.Sprintf("[%s]", l.formatTime(time.Now())))
+	}
+
+	msg := Map(m, func(el any) string {
+		return fmt.Sprintf("%v", el)
+	})
+
+	return fmt.Sprintf("%s %v", strings.Join(args, " "), strings.Join(msg, " "))
+}
+
+func (l *Logger) print(level LogLevel, m []any) {
+	if l.level.n < level.n {
+		return
+	}
+
+	for _, writer := range l.writers {
+		err := writer.writeFn(level, l.prefix, l.formatFullTraceback(l.getFullTraceback(0)), m)
+		if err != nil {
+			l.Error(err)
+		}
+	}
+}

laniakea/methods.go

@@ -0,0 +1,169 @@
+package laniakea
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+var NoParams = make(map[string]any)
+
+func (b *Bot) Updates() ([]*Update, error) {
+	params := make(map[string]any)
+	params["offset"] = b.updateOffset
+	params["timeout"] = 30
+	params["allowed_updates"] = b.updateTypes
+
+	data, err := b.request("getUpdates", params)
+	if err != nil {
+		return nil, err
+	}
+	res := make([]*Update, 0)
+	for _, u := range data["data"].([]any) {
+		updateObj := new(Update)
+		data, err := json.Marshal(u)
+		if err != nil {
+			return res, err
+		}
+		err = json.Unmarshal(data, updateObj)
+		if err != nil {
+			return res, err
+		}
+		//err = MapToStruct(u.(map[string]any), updateObj)
+		//if err != nil {
+		//	return res, err
+		//}
+		b.updateOffset = updateObj.UpdateID + 1
+		err = b.updateQueue.Enqueue(updateObj)
+		if err != nil {
+			return res, err
+		}
+		res = append(res, updateObj)
+
+		if b.debug && b.requestLogger != nil {
+			j, err := MapToJson(u.(map[string]interface{}))
+			if err != nil {
+				b.logger.Error(err)
+			}
+			b.requestLogger.Debug(fmt.Sprintf("UPDATE %s", j))
+		}
+	}
+	return res, err
+}
+
+func (b *Bot) GetMe() (*User, error) {
+	data, err := b.request("getMe", NoParams)
+	if err != nil {
+		return nil, err
+	}
+	user := new(User)
+	err = MapToStruct(data, user)
+	return user, err
+}
+
+type SendMessageP struct {
+	BusinessConnectionID string               `json:"business_connection_id,omitempty"`
+	ChatID               int                  `json:"chat_id"`
+	MessageThreadID      int                  `json:"message_thread_id,omitempty"`
+	ParseMode            ParseMode            `json:"parse_mode,omitempty"`
+	Text                 string               `json:"text"`
+	Entities             []*MessageEntity     `json:"entities,omitempty"`
+	LinkPreviewOptions   *LinkPreviewOptions  `json:"link_preview_options,omitempty"`
+	DisableNotifications bool                 `json:"disable_notifications,omitempty"`
+	ProtectContent       bool                 `json:"protect_content,omitempty"`
+	AllowPaidBroadcast   bool                 `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID      string               `json:"message_effect_id,omitempty"`
+	ReplyParameters      *ReplyParameters     `json:"reply_parameters,omitempty"`
+	ReplyMarkup          InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+}
+
+func (b *Bot) SendMessage(params *SendMessageP) (*Message, error) {
+	data, err := b.request("sendMessage", params)
+	if err != nil {
+		return nil, err
+	}
+	message := new(Message)
+	err = MapToStruct(data, message)
+	return message, err
+}
+
+type SendPhotoP struct {
+	BusinessConnectionID  string               `json:"business_connection_id,omitempty"`
+	ChatID                int                  `json:"chat_id"`
+	MessageThreadID       int                  `json:"message_thread_id,omitempty"`
+	ParseMode             ParseMode            `json:"parse_mode,omitempty"`
+	Photo                 string               `json:"photo"`
+	Caption               string               `json:"caption,omitempty"`
+	CaptionEntities       []*MessageEntity     `json:"caption_entities,omitempty"`
+	ShowCaptionAboveMedia bool                 `json:"show_caption_above_media"`
+	HasSpoiler            bool                 `json:"has_spoiler"`
+	DisableNotifications  bool                 `json:"disable_notifications,omitempty"`
+	ProtectContent        bool                 `json:"protect_content,omitempty"`
+	AllowPaidBroadcast    bool                 `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID       string               `json:"message_effect_id,omitempty"`
+	ReplyMarkup           InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+}
+
+func (b *Bot) SendPhoto(params *SendPhotoP) (*Message, error) {
+	data, err := b.request("sendPhoto", params)
+	if err != nil {
+		return nil, err
+	}
+	message := new(Message)
+	err = MapToStruct(data, message)
+	return message, err
+}
+
+type EditMessageTextP struct {
+	BusinessConnectionID string               `json:"business_connection_id,omitempty"`
+	ChatID               int                  `json:"chat_id,omitempty"`
+	MessageID            int                  `json:"message_id,omitempty"`
+	InlineMessageID      string               `json:"inline_message_id,omitempty"`
+	Text                 string               `json:"text"`
+	ParseMode            ParseMode            `json:"parse_mode,omitempty"`
+	ReplyMarkup          InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+}
+
+func (b *Bot) EditMessageText(params *EditMessageTextP) (*Message, error) {
+	data, err := b.request("editMessageText", params)
+	if err != nil {
+		return nil, err
+	}
+	message := new(Message)
+	err = MapToStruct(data, message)
+	return message, err
+}
+
+type EditMessageCaptionP struct {
+	BusinessConnectionID string               `json:"business_connection_id,omitempty"`
+	ChatID               int                  `json:"chat_id,omitempty"`
+	MessageID            int                  `json:"message_id,omitempty"`
+	InlineMessageID      string               `json:"inline_message_id,omitempty"`
+	Caption              string               `json:"caption"`
+	ParseMode            ParseMode            `json:"parse_mode,omitempty"`
+	ReplyMarkup          InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+}
+
+func (b *Bot) EditMessageCaption(params *EditMessageCaptionP) (*Message, error) {
+	data, err := b.request("editMessageCaption", params)
+	if err != nil {
+		return nil, err
+	}
+	message := new(Message)
+	err = MapToStruct(data, message)
+	return message, err
+}
+
+type DeleteMessageP struct {
+	ChatID    int `json:"chat_id"`
+	MessageID int `json:"message_id"`
+}
+
+func (b *Bot) DeleteMessage(params *DeleteMessageP) (*Message, error) {
+	data, err := b.request("deleteMessage", params)
+	if err != nil {
+		return nil, err
+	}
+	message := new(Message)
+	err = MapToStruct(data, message)
+	return message, err
+}

laniakea/plugins.go

@@ -0,0 +1,116 @@
+package laniakea
+
+import "log"
+
+type CommandExecutor func(ctx *MsgContext, dbContext *DatabaseContext)
+
+type PluginBuilder struct {
+	name           string
+	commands       map[string]*CommandExecutor
+	payloads       map[string]*CommandExecutor
+	updateListener *CommandExecutor
+}
+
+type Plugin struct {
+	Name           string
+	Commands       map[string]*CommandExecutor
+	Payloads       map[string]*CommandExecutor
+	UpdateListener *CommandExecutor
+}
+
+func NewPlugin(name string) *PluginBuilder {
+	return &PluginBuilder{
+		name:     name,
+		commands: make(map[string]*CommandExecutor),
+		payloads: make(map[string]*CommandExecutor),
+	}
+}
+
+func (p *PluginBuilder) Command(f CommandExecutor, cmd ...string) *PluginBuilder {
+	for _, c := range cmd {
+		p.commands[c] = &f
+	}
+	return p
+}
+
+func (p *PluginBuilder) Payload(f CommandExecutor, payloads ...string) *PluginBuilder {
+	for _, payload := range payloads {
+		p.payloads[payload] = &f
+	}
+	return p
+}
+
+func (p *PluginBuilder) UpdateListener(listener CommandExecutor) *PluginBuilder {
+	p.updateListener = &listener
+	return p
+}
+
+func (p *PluginBuilder) Build() *Plugin {
+	if len(p.commands) == 0 && len(p.payloads) == 0 {
+		log.Println("no command or payloads")
+	}
+	plugin := &Plugin{
+		Name:           p.name,
+		Commands:       p.commands,
+		Payloads:       p.payloads,
+		UpdateListener: p.updateListener,
+	}
+	return plugin
+}
+
+func (p *Plugin) Execute(cmd string, ctx *MsgContext, dbContext *DatabaseContext) {
+	(*p.Commands[cmd])(ctx, dbContext)
+}
+
+func (p *Plugin) ExecutePayload(payload string, ctx *MsgContext, dbContext *DatabaseContext) {
+	(*p.Payloads[payload])(ctx, dbContext)
+}
+
+type Middleware struct {
+	Name     string
+	Executor *CommandExecutor
+	Order    int
+	Async    bool
+}
+type MiddlewareBuilder struct {
+	name     string
+	executor *CommandExecutor
+	order    int
+	async    bool
+}
+
+func NewMiddleware(name string) *MiddlewareBuilder {
+	return &MiddlewareBuilder{name: name, async: false}
+}
+func (m *MiddlewareBuilder) SetName(name string) *MiddlewareBuilder {
+	m.name = name
+	return m
+}
+func (m *MiddlewareBuilder) SetExecutor(executor CommandExecutor) *MiddlewareBuilder {
+	m.executor = &executor
+	return m
+}
+func (m *MiddlewareBuilder) SetOrder(order int) *MiddlewareBuilder {
+	m.order = order
+	return m
+}
+func (m *MiddlewareBuilder) SetAsync(async bool) *MiddlewareBuilder {
+	m.async = async
+	return m
+}
+func (m *MiddlewareBuilder) Build() *Middleware {
+	return &Middleware{
+		Name:     m.name,
+		Executor: m.executor,
+		Order:    m.order,
+		Async:    m.async,
+	}
+}
+func (m *Middleware) Execute(ctx *MsgContext, db *DatabaseContext) {
+	exec := *m.Executor
+	if m.Async {
+		go exec(ctx, db)
+	} else {
+		exec(ctx, db)
+	}
+}

laniakea/queue.go

@@ -0,0 +1,69 @@
+package laniakea
+
+import (
+	"fmt"
+	"sync"
+)
+
+type Queue[T any] struct {
+	size  uint64
+	mu    sync.RWMutex
+	queue []T
+}
+
+func CreateQueue[T any](size uint64) *Queue[T] {
+	return &Queue[T]{
+		queue: make([]T, 0),
+		size:  size,
+	}
+}
+
+func (q *Queue[T]) Enqueue(el T) error {
+	if q.IsFull() {
+		return fmt.Errorf("queue full")
+	}
+	q.queue = append(q.queue, el)
+	return nil
+}
+
+func (q *Queue[T]) Peak() T {
+	q.mu.RLock()
+	defer q.mu.RUnlock()
+	return q.queue[0]
+}
+
+func (q *Queue[T]) IsEmpty() bool {
+	return q.Length() == 0
+}
+
+func (q *Queue[T]) IsFull() bool {
+	return q.Length() == q.size
+}
+
+func (q *Queue[T]) Length() uint64 {
+	q.mu.RLock()
+	defer q.mu.RUnlock()
+	return uint64(len(q.queue))
+}
+
+func (q *Queue[T]) Dequeue() T {
+	q.mu.RLock()
+	el := q.queue[0]
+	q.mu.RUnlock()
+
+	if q.Length() == 1 {
+		q.mu.Lock()
+		q.queue = make([]T, 0)
+		q.mu.Unlock()
+		return el
+	}
+
+	q.mu.Lock()
+	q.queue = q.queue[1:]
+	q.mu.Unlock()
+	return el
+}
+
+func (q *Queue[T]) Raw() []T {
+	return q.queue
+}

laniakea/types.go

@@ -0,0 +1,174 @@
+package laniakea
+
+type Update struct {
+	UpdateID               int                          `json:"update_id"`
+	Message                *Message                     `json:"message"`
+	EditedMessage          *Message                     `json:"edited_message,omitempty"`
+	ChannelPost            *Message                     `json:"channel_post,omitempty"`
+	EditedChannelPost      *Message                     `json:"edited_channel_post,omitempty"`
+	BusinessConnection     *BusinessConnection          `json:"business_connection,omitempty"`
+	BusinessMessage        *Message                     `json:"business_message,omitempty"`
+	EditedBusinessMessage  *Message                     `json:"edited_business_message,omitempty"`
+	DeletedBusinessMessage *Message                     `json:"deleted_business_messages,omitempty"`
+	MessageReaction        *MessageReactionUpdated      `json:"message_reaction,omitempty"`
+	MessageReactionCount   *MessageReactionCountUpdated `json:"message_reaction_count,omitempty"`
+	CallbackQuery          *CallbackQuery               `json:"callback_query,omitempty"`
+	InlineQuery            int
+	ChosenInlineResult     int
+}
+
+type User struct {
+	ID                      int    `json:"id"`
+	IsBot                   bool   `json:"is_bot"`
+	FirstName               string `json:"first_name"`
+	LastName                string `json:"last_name,omitempty"`
+	Username                string `json:"username,omitempty"`
+	LanguageCode            string `json:"language_code,omitempty"`
+	IsPremium               bool   `json:"is_premium,omitempty"`
+	AddedToAttachmentMenu   bool   `json:"added_to_attachment_menu,omitempty"`
+	CanJoinGroups           bool   `json:"can_join_groups,omitempty"`
+	CanReadAllGroupMessages bool   `json:"can_read_all_group_messages,omitempty"`
+	SupportsInlineQueries   bool   `json:"supports_inline_queries,omitempty"`
+	CanConnectToBusiness    bool   `json:"can_connect_to_business,omitempty"`
+	HasMainWebApp           bool   `json:"has_main_web_app,omitempty"`
+}
+
+type Chat struct {
+	ID        int    `json:"id"`
+	Type      string `json:"type"`
+	Title     string `json:"title,omitempty"`
+	Username  string `json:"username,omitempty"`
+	FirstName string `json:"first_name,omitempty"`
+	LastName  string `json:"last_name,omitempty"`
+	IsForum   bool   `json:"is_forum,omitempty"`
+}
+
+type MessageReplyMarkup struct {
+	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard"`
+}
+
+type Message struct {
+	MessageID       int    `json:"message_id"`
+	MessageThreadID int    `json:"message_thread_id,omitempty"`
+	From            *User  `json:"from,omitempty"`
+	Chat            *Chat  `json:"chat,omitempty"`
+	Text            string `json:"text"`
+
+	Photo          []*PhotoSize `json:"photo,omitempty"`
+	Caption        string       `json:"caption,omitempty"`
+	ReplyToMessage *Message     `json:"reply_to_message"`
+
+	ReplyMarkup *MessageReplyMarkup `json:"reply_markup,omitempty"`
+}
+
+type InaccessableMessage struct {
+	Chat      *Chat `json:"chat"`
+	MessageID int   `json:"message_id"`
+	Date      int   `json:"date"`
+}
+
+type MaybeInaccessibleMessage struct {
+}
+
+type MessageEntity struct {
+	Type          string `json:"type"`
+	Offset        int    `json:"offset"`
+	Length        int    `json:"length"`
+	URL           string `json:"url,omitempty"`
+	User          *User  `json:"user,omitempty"`
+	Language      string `json:"language,omitempty"`
+	CustomEmojiID string `json:"custom_emoji_id,omitempty"`
+}
+
+type ReplyParameters struct {
+	MessageID                int              `json:"message_id"`
+	ChatID                   int              `json:"chat_id,omitempty"`
+	AllowSendingWithoutReply bool             `json:"allow_sending_without_reply,omitempty"`
+	Quote                    string           `json:"quote,omitempty"`
+	QuoteParsingMode         string           `json:"quote_parsing_mode,omitempty"`
+	QuoteEntities            []*MessageEntity `json:"quote_entities,omitempty"`
+	QuotePosition            int              `json:"quote_postigin,omitempty"`
+}
+
+type PhotoSize struct {
+	FileID       string `json:"file_id"`
+	FileUniqueID string `json:"file_unique_id"`
+	Width        int    `json:"width"`
+	Height       int    `json:"height"`
+	FileSize     int    `json:"file_size,omitempty"`
+}
+
+type LinkPreviewOptions struct {
+	IsDisabled       bool   `json:"is_disabled,omitempty"`
+	URL              string `json:"url,omitempty"`
+	PreferSmallMedia bool   `json:"prefer_small_media,omitempty"`
+	PreferLargeMedia bool   `json:"prefer_large_media,omitempty"`
+	ShowAboveText    bool   `json:"show_above_text,omitempty"`
+}
+
+type InlineKeyboardMarkup struct {
+	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard,omitempty"`
+}
+
+type InlineKeyboardButton struct {
+	Text         string `json:"text"`
+	URL          string `json:"url,omitempty"`
+	CallbackData string `json:"callback_data,omitempty"`
+}
+
+type ReplyKeyboardMarkup struct {
+	Keyboard [][]int `json:"keyboard"`
+}
+
+type CallbackQuery struct {
+	ID      string   `json:"id"`
+	From    *User    `json:"from"`
+	Message *Message `json:"message"`
+
+	Data string `json:"data"`
+}
+
+type BusinessConnection struct {
+	ID         string `json:"id"`
+	User       *User  `json:"user"`
+	UserChatID int    `json:"user_chat_id"`
+	Date       int    `json:"date"`
+	CanReply   bool   `json:"can_reply"`
+	IsEnabled  bool   `json:"id_enabled"`
+}
+
+type MessageReactionUpdated struct {
+	Chat        *Chat           `json:"chat"`
+	MessageID   int             `json:"message_id"`
+	User        *User           `json:"user,omitempty"`
+	ActorChat   *Chat           `json:"actor_chat"`
+	Date        int             `json:"date"`
+	OldReaction []*ReactionType `json:"old_reaction"`
+	NewReaction []*ReactionType `json:"new_reaction"`
+}
+
+type MessageReactionCountUpdated struct {
+	Chat      *Chat            `json:"chat"`
+	MessageID int              `json:"message_id"`
+	Date      int              `json:"date"`
+	Reactions []*ReactionCount `json:"reactions"`
+}
+
+type ReactionType struct {
+	Type string `json:"type"`
+}
+type ReactionTypeEmoji struct {
+	ReactionType
+	Emoji string `json:"emoji"`
+}
+type ReactionTypeCustomEmoji struct {
+	ReactionType
+	CustomEmojiID string `json:"custom_emoji_id"`
+}
+type ReactionTypePaid struct {
+	ReactionType
+}
+type ReactionCount struct {
+	Type       *ReactionType `json:"type"`
+	TotalCount int           `json:"total_count"`
+}

laniakea/utils.go

@@ -0,0 +1,108 @@
+package laniakea
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+func MapToStruct(m map[string]interface{}, s interface{}) error {
+	data, err := json.Marshal(m)
+	if err != nil {
+		return err
+	}
+	err = json.Unmarshal(data, s)
+	return err
+}
+
+func MapToJson(m map[string]interface{}) (string, error) {
+	data, err := json.Marshal(m)
+	return string(data), err
+}
+
+func StructToMap(s interface{}) (map[string]interface{}, error) {
+	data, err := json.Marshal(s)
+	if err != nil {
+		return nil, err
+	}
+	m := make(map[string]interface{})
+	err = json.Unmarshal(data, &m)
+	return m, err
+}
+
+func Map[T, V any](ts []T, fn func(T) V) []V {
+	result := make([]V, len(ts))
+	for i, t := range ts {
+		result[i] = fn(t)
+	}
+	return result
+}
+
+func EscapeMarkdown(s string) string {
+	s = strings.ReplaceAll(s, "_", `\_`)
+	s = strings.ReplaceAll(s, "*", `\*`)
+	s = strings.ReplaceAll(s, "[", `\[`)
+	return strings.ReplaceAll(s, "`", "\\`")
+}
+
+func EscapeMarkdownV2(s string) string {
+	symbols := []string{"_", "*", "[", "]", "(", ")", "~", "`", ">", "#", "+", "-", "=", "|", "{", "}", ".", "!"}
+	for _, symbol := range symbols {
+		s = strings.ReplaceAll(s, symbol, fmt.Sprintf("\\%s", symbol))
+	}
+	return s
+}
+
+func GetUnclosedTag(markdown string) string {
+	// order is important!
+	var tags = []string{
+		"```",
+		"`",
+		"*",
+		"_",
+	}
+	var currentTag = ""
+
+	markdownRunes := []rune(markdown)
+
+	var i = 0
+outer:
+	for i < len(markdownRunes) {
+		// skip escaped characters (only outside tags)
+		if markdownRunes[i] == '\\' && currentTag == "" {
+			i += 2
+			continue
+		}
+		if currentTag != "" {
+			if strings.HasPrefix(string(markdownRunes[i:]), currentTag) {
+				// turn a tag off
+				i += len(currentTag)
+				currentTag = ""
+				continue
+			}
+		} else {
+			for _, tag := range tags {
+				if strings.HasPrefix(string(markdownRunes[i:]), tag) {
+					// turn a tag on
+					currentTag = tag
+					i += len(currentTag)
+					continue outer
+				}
+			}
+		}
+		i++
+	}
+
+	return currentTag
+}
+func IsValid(markdown string) bool {
+	return GetUnclosedTag(markdown) == ""
+}
+
+func FixMarkdown(markdown string) string {
+	tag := GetUnclosedTag(markdown)
+	if tag == "" {
+		return markdown
+	}
+	return markdown + tag
+}

laniakea/version.go

@@ -0,0 +1,12 @@
+package laniakea
+
+import "os"
+
+const (
+	VersionString = "0.2.0"
+	VersionMajor  = 0
+	VersionMinor  = 2
+	VersionPatch  = 0
+)
+
+var GoVersion = os.Getenv("GoV")