build(deps): bump google.golang.org/genai from 1.69.0 to 1.70.0 in the go-minor-patch group

go.mod

@@ -24,7 +24,7 @@ require (
 	go.uber.org/zap v1.28.0
 	golang.org/x/text v0.41.0
 	golang.org/x/time v0.15.0
-	google.golang.org/genai v1.69.0
+	google.golang.org/genai v1.70.0
 )
 
 require (

go.sum

@@ -218,8 +218,8 @@ golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
 golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
 gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
 gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E=
-google.golang.org/genai v1.69.0 h1:quP3Rbiz0Mn+zPfXsWHQQwOx8IfO2MnQehZUbrJ/jPo=
-google.golang.org/genai v1.69.0/go.mod h1:mDdPDFXo1Ats7f1WXVyZgWb/CkMzFWTWJruIMy7hGIU=
+google.golang.org/genai v1.70.0 h1:V9oYOBvTDYbmeklOHjvxGeeLau71WiS2CWKrktQtDok=
+google.golang.org/genai v1.70.0/go.mod h1:mDdPDFXo1Ats7f1WXVyZgWb/CkMzFWTWJruIMy7hGIU=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20260720211330-0afa2a65878a h1:qI/YMH1ep2qQtqcp00gMQyoU7mjvbhg88GJKCvfoLj0=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20260720211330-0afa2a65878a/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
 google.golang.org/grpc v1.82.1 h1:NnAxzGRA0677vCa4BUkOAnO5+FfQqVl9iUXeD0IqcGE=

internal/app/router.go

@@ -76,6 +76,11 @@ func (r *Router) RegisterRoutes(bh *th.BotHandler) {
 		return nil
 	}, th.CommandEqual("help"))
 
+	bh.HandleMessage(func(ctx *th.Context, m telego.Message) error {
+		r.handlers.Grok.FactCheck(ctx, &m)
+		return nil
+	}, grokFactCheckPredicate())
+
 	// Non-command messages containing a URL start a direct download; registered last so commands win.
 	bh.HandleMessage(func(ctx *th.Context, m telego.Message) error {
 		r.handlers.Clip.DirectLink(ctx, &m, downloader.ExtractFirstURL(m.Text))
@@ -118,6 +123,30 @@ func clipHandler(h *handlers.Handlers, command string) th.MessageHandler {
 	}
 }
 
+func grokFactCheckPredicate() th.Predicate {
+	return func(_ context.Context, update telego.Update) bool {
+		return isGrokFactCheck(update.Message)
+	}
+}
+
+func isGrokFactCheck(m *telego.Message) bool {
+	if m == nil || m.ReplyToMessage == nil || m.Text == "" {
+		return false
+	}
+	replacer := strings.NewReplacer(",", " ", ":", " ", "?", " ")
+	words := strings.Fields(replacer.Replace(strings.ToLower(m.Text)))
+	if len(words) < 3 {
+		return false
+	}
+	if words[0] != "@grok" {
+		return false
+	}
+	if words[1] == "это" && words[2] == "правда" {
+		return true
+	}
+	return words[1] == "is" && words[2] == "this" && len(words) >= 4 && words[3] == "true"
+}
+
 // messageWithURL matches non-command text messages carrying a downloadable URL.
 func messageWithURL() th.Predicate {
 	return func(_ context.Context, update telego.Update) bool {

internal/app/router_test.go

@@ -0,0 +1,120 @@
+package app
+
+import (
+	"testing"
+
+	"github.com/mymmrac/telego"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsGrokFactCheck(t *testing.T) {
+	replyMsg := &telego.Message{
+		MessageID: 100,
+		Text:      "Target text to verify",
+	}
+
+	tests := []struct {
+		name     string
+		msg      *telego.Message
+		expected bool
+	}{
+		{
+			name:     "nil message",
+			msg:      nil,
+			expected: false,
+		},
+		{
+			name: "no reply to message",
+			msg: &telego.Message{
+				Text: "@grok это правда?",
+			},
+			expected: false,
+		},
+		{
+			name: "empty text",
+			msg: &telego.Message{
+				ReplyToMessage: replyMsg,
+				Text:           "",
+			},
+			expected: false,
+		},
+		{
+			name: "ru exact match",
+			msg: &telego.Message{
+				ReplyToMessage: replyMsg,
+				Text:           "@grok это правда",
+			},
+			expected: true,
+		},
+		{
+			name: "ru with comma and question mark",
+			msg: &telego.Message{
+				ReplyToMessage: replyMsg,
+				Text:           "@grok, это правда?",
+			},
+			expected: true,
+		},
+		{
+			name: "ru with colon and extra text",
+			msg: &telego.Message{
+				ReplyToMessage: replyMsg,
+				Text:           "@grok: это правда или фейк?",
+			},
+			expected: true,
+		},
+		{
+			name: "ru uppercase",
+			msg: &telego.Message{
+				ReplyToMessage: replyMsg,
+				Text:           "@GROK ЭТО ПРАВДА?",
+			},
+			expected: true,
+		},
+		{
+			name: "en exact match",
+			msg: &telego.Message{
+				ReplyToMessage: replyMsg,
+				Text:           "@grok is this true",
+			},
+			expected: true,
+		},
+		{
+			name: "en with question mark and comma",
+			msg: &telego.Message{
+				ReplyToMessage: replyMsg,
+				Text:           "@grok, is this true?",
+			},
+			expected: true,
+		},
+		{
+			name: "en with extra words",
+			msg: &telego.Message{
+				ReplyToMessage: replyMsg,
+				Text:           "@grok is this true: please check",
+			},
+			expected: true,
+		},
+		{
+			name: "unrelated grok mention",
+			msg: &telego.Message{
+				ReplyToMessage: replyMsg,
+				Text:           "@grok hello there",
+			},
+			expected: false,
+		},
+		{
+			name: "just mention",
+			msg: &telego.Message{
+				ReplyToMessage: replyMsg,
+				Text:           "@grok",
+			},
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, isGrokFactCheck(tt.msg))
+		})
+	}
+}

internal/handlers/grok.go

@@ -0,0 +1,117 @@
+package handlers
+
+import (
+	"context"
+	"html"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/mymmrac/telego"
+	"go.uber.org/zap"
+
+	"gemfactory/internal/middleware"
+	"gemfactory/internal/translate"
+)
+
+type GrokHandlers struct {
+	*BaseHandler
+	limiter *middleware.GrokLimiter
+}
+
+func NewGrokHandlers(base *BaseHandler) *GrokHandlers {
+	return &GrokHandlers{
+		BaseHandler: base,
+		limiter:     middleware.NewGrokLimiter(),
+	}
+}
+
+func (h *GrokHandlers) FactCheck(ctx context.Context, message *telego.Message) {
+	if message == nil || message.ReplyToMessage == nil {
+		return
+	}
+
+	enabledStr, err := h.Services.Config.Get(ctx, "GROK_ENABLED")
+	if err == nil && !translate.IsTruthy(enabledStr) {
+		return
+	}
+
+	isAdmin := message.From != nil && (message.From.Username == h.Config.AdminUsername || h.IsAdmin(message.From))
+	if !isAdmin {
+		rateLimit := 3
+		if rlStr, err := h.Services.Config.Get(ctx, "GROK_RATE_LIMIT"); err == nil && rlStr != "" {
+			if v, err := strconv.Atoi(rlStr); err == nil && v > 0 {
+				rateLimit = v
+			}
+		}
+
+		userID := int64(0)
+		if message.From != nil {
+			userID = message.From.ID
+		}
+
+		allowed, shouldNotify := h.limiter.Check(userID, rateLimit, time.Minute)
+		if !allowed {
+			if shouldNotify {
+				_, _ = h.TG.SendMessageRaw(ctx, message.Chat.ID, "Мне лень", message.MessageID)
+			}
+			return
+		}
+	}
+
+	replyMsg := message.ReplyToMessage
+	replyText := replyMsg.Text
+	if replyText == "" {
+		replyText = replyMsg.Caption
+	}
+
+	var targetText string
+	if message.Quote != nil && strings.TrimSpace(message.Quote.Text) != "" {
+		targetText = "Проверяемая цитата:\n\"" + message.Quote.Text + "\"\n\nКонтекст исходного сообщения:\n\"" + replyText + "\""
+	} else {
+		targetText = "Текст для проверки:\n\"" + replyText + "\""
+	}
+
+	if strings.TrimSpace(replyText) == "" && (message.Quote == nil || strings.TrimSpace(message.Quote.Text) == "") {
+		return
+	}
+
+	maxChars := 3000
+	if mcStr, err := h.Services.Config.Get(ctx, "GROK_MAX_CHARS"); err == nil && mcStr != "" {
+		if v, err := strconv.Atoi(mcStr); err == nil && v > 0 {
+			maxChars = v
+		}
+	}
+
+	runes := []rune(targetText)
+	if len(runes) > maxChars {
+		targetText = string(runes[:maxChars])
+	}
+	if strings.TrimSpace(targetText) == "" {
+		return
+	}
+
+	prompt, err := h.Services.Config.Get(ctx, "GROK_PROMPT")
+	if err != nil || strings.TrimSpace(prompt) == "" {
+		prompt = translate.DefaultGrokPrompt
+	}
+
+	cfg := translate.ResolveConfig(func(k string) (string, bool) {
+		if h.Services == nil || h.Services.Config == nil {
+			return "", false
+		}
+		v, err := h.Services.Config.Get(ctx, k)
+		if err != nil || strings.TrimSpace(v) == "" {
+			return "", false
+		}
+		return strings.TrimSpace(v), true
+	})
+
+	resp, _, err := translate.Complete(ctx, prompt, targetText, cfg)
+	if err != nil {
+		h.Logger.Error("grok factcheck failed", zap.Error(err))
+		return
+	}
+
+	_, _ = h.TG.SendMessageRaw(ctx, message.Chat.ID, html.EscapeString(resp), message.MessageID)
+}

internal/handlers/handlers.go

@@ -15,6 +15,7 @@ type Handlers struct {
 	User  *UserHandlers
 	Admin *AdminHandlers
 	Clip  *ClipHandlers
+	Grok  *GrokHandlers
 }
 
 func New(services *service.Services, config *config.Config, keyboard *keyboard.Manager, logger *zap.Logger, tg *telegram.Client, downloads *downloader.Service) *Handlers {
@@ -23,11 +24,13 @@ func New(services *service.Services, config *config.Config, keyboard *keyboard.M
 	user := NewUserHandlers(base)
 	admin := NewAdminHandlers(base)
 	clip := NewClipHandlers(base, downloads, user)
+	grok := NewGrokHandlers(base)
 
 	return &Handlers{
 		User:  user,
 		Admin: admin,
 		Clip:  clip,
+		Grok:  grok,
 	}
 }
 

internal/middleware/grok_limiter.go

@@ -0,0 +1,56 @@
+package middleware
+
+import (
+	"slices"
+	"sync"
+	"time"
+
+	lru "github.com/hashicorp/golang-lru/v2/expirable"
+)
+
+type grokUserState struct {
+	requests []time.Time
+	notified bool
+}
+
+type GrokLimiter struct {
+	mu    sync.Mutex
+	cache *lru.LRU[int64, *grokUserState]
+}
+
+func NewGrokLimiter() *GrokLimiter {
+	return &GrokLimiter{
+		cache: lru.NewLRU[int64, *grokUserState](maxTrackedUsers, nil, 10*time.Minute),
+	}
+}
+
+func (l *GrokLimiter) Check(userID int64, limit int, window time.Duration) (bool, bool) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	now := time.Now()
+	windowStart := now.Add(-window)
+
+	state, ok := l.cache.Get(userID)
+	if !ok || state == nil {
+		state = &grokUserState{}
+		l.cache.Add(userID, state)
+	}
+
+	state.requests = slices.DeleteFunc(state.requests, func(reqTime time.Time) bool {
+		return !reqTime.After(windowStart)
+	})
+
+	if len(state.requests) < limit {
+		state.requests = append(state.requests, now)
+		state.notified = false
+		return true, false
+	}
+
+	if !state.notified {
+		state.notified = true
+		return false, true
+	}
+
+	return false, false
+}