Maven/cmd/mavend/quiet_toggle.go

// Quiet-mode toggle recognition — the pre-route keyword check that lets
// "тихий режим" flip the daemon-wide quiet_hours config without going through
// the router. Moved out of voice.go unchanged (Vikunja #321); the tests live in
// quiet_toggle_test.go.
package main

import (
	"context"
	"log"
	"strings"
	"unicode"

	"github.com/kami/maven/internal/ipc"
)

// resolveQuietToggle — pre-route keyword check. Returns (reply, true) when
// the utterance is a quiet-on/off command; ("", false) otherwise. Called from
// runTurn BEFORE the router so a classifier miscue can't drop it — which means
// both the voice path and the text path (mavweb /api/chat, telegram) reach it,
// so a false positive here is a network-reachable way to flip a daemon-wide
// setting. See classifyQuietToggle for the matching rule.
func (h *reactiveHandler) resolveQuietToggle(ctx context.Context, text string) (string, bool) {
	on, off := classifyQuietToggle(text)
	if !on && !off {
		return "", false
	}
	val := "false"
	reply := "тихий режим выключен."
	if on {
		val = "true"
		reply = "тихий режим включён. буду реже напоминать."
	}
	if _, err := h.api.WriteFact(ctx, ipc.WriteFactReq{
		Ts:         h.now(),
		Kind:       "config",
		Key:        "quiet_hours",
		Value:      val,
		Source:     "tap:voice",
		Confidence: 1.0,
	}); err != nil {
		log.Printf("voice: write quiet_hours: %v", err)
		return "не получилось переключить тихий режим.", true
	}
	return reply, true
}

// quietInflections — the inflectional endings a stem may carry and still be
// the same word. Adjective/adverb/noun/verb endings, all ≤3 letters. This is
// what separates "тихий"/"тихом"/"тихо" (stem "тих" + a real ending) from
// "тихонько"/"потихоньку", which are different words: "онько" is not an
// ending, and "потихоньку" doesn't start with the stem at all.
var quietInflections = []string{
	"", "а", "е", "и", "й", "о", "у", "ы", "ю", "я",
	"ая", "ее", "ей", "ем", "ие", "ий", "им", "их", "ия", "ию", "ое", "ой", "ом", "ую", "ые", "ый", "ым", "ых", "ья",
	"ами", "ого", "ому", "ыми", "ать", "ить", "ять",
}

// quietStem reports whether tok is the given stem carrying at most one
// inflectional ending. Word boundaries come from tokenisation (see
// quietTokens), not from a regexp — Go's \b is ASCII-oriented and treats every
// Cyrillic letter as a non-word character, so `\bтих\b` would happily match
// inside "тихонько". Comparing whole tokens sidesteps that entirely.
func quietStem(tok, stem string) bool {
	if !strings.HasPrefix(tok, stem) {
		return false
	}
	suffix := tok[len(stem):]
	for _, e := range quietInflections {
		if suffix == e {
			return true
		}
	}
	return false
}

// quietTokens splits an utterance into lowercase word tokens, dropping
// punctuation and spacing. Unicode-aware, so Cyrillic words tokenise the same
// way ASCII ones do.
func quietTokens(text string) []string {
	return strings.FieldsFunc(strings.ToLower(strings.TrimSpace(text)), func(r rune) bool {
		return !unicode.IsLetter(r) && !unicode.IsDigit(r)
	})
}

// quietPhrase matches a pattern (a sequence of stems) against the token list.
// Multi-word patterns match any contiguous run of tokens — "включи тихий
// режим" carries "тихий режим". Single-word patterns match ONLY when they are
// the whole utterance: bare "тихо" is a command, but "в комнате тихо" is a
// remark about the room and must not flip a daemon-wide setting.
func quietPhrase(tokens, pattern []string) bool {
	if len(pattern) == 0 || len(tokens) < len(pattern) {
		return false
	}
	if len(pattern) == 1 {
		return len(tokens) == 1 && quietStem(tokens[0], pattern[0])
	}
	for i := 0; i+len(pattern) <= len(tokens); i++ {
		hit := true
		for j, stem := range pattern {
			if !quietStem(tokens[i+j], stem) {
				hit = false
				break
			}
		}
		if hit {
			return true
		}
	}
	return false
}

// quietOffPhrases / quietOnPhrases — the toggle vocabulary, as stem sequences.
var (
	quietOffPhrases = [][]string{
		{"quiet", "off"}, {"quiet", "end"},
		{"громк", "режим"}, {"шумн", "режим"},
		{"отмен", "тих"}, {"выключ", "тих"}, {"не", "тих"},
	}
	quietOnPhrases = [][]string{
		{"quiet", "on"}, {"quiet", "mode"},
		{"тих", "режим"}, {"не", "шум"}, {"не", "беспоко"},
		{"тих"},
	}
)

// classifyQuietToggle reads an utterance as a quiet-mode command. OFF is
// resolved before ON for the same reason classifyConfirm checks negatives
// first: the OFF phrases are built out of the ON words ("выключи тихий"
// contains "тихий"), so scanning ON first would shadow them and "выключи
// тихий режим" would turn quiet mode on. Negation wins.
func classifyQuietToggle(text string) (on, off bool) {
	tokens := quietTokens(text)
	for _, p := range quietOffPhrases {
		if quietPhrase(tokens, p) {
			return false, true
		}
	}
	for _, p := range quietOnPhrases {
		if quietPhrase(tokens, p) {
			return true, false
		}
	}
	return false, false
}