claude
4bb7555459
93 semantic seed families across 6 routes. Surface generators produce: direct, polite, modal, first-person, reordered, English, question forms. Each seed specifies verb forms, subjects, objects, values, tags.
1416 lines
50 KiB
Go
1416 lines
50 KiB
Go
// corpus-factory generates the expanded semantic routing corpus from
|
||
// deterministic seed specifications. Every surface form is derived
|
||
// mechanically from a SemanticSeed — no hand-authored sentences.
|
||
//
|
||
// Usage:
|
||
//
|
||
// go run ./cmd/corpus-factory/ -out internal/router/semantic/corpus_v2.json
|
||
package main
|
||
|
||
import (
|
||
"crypto/sha256"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"flag"
|
||
"fmt"
|
||
"log"
|
||
"os"
|
||
"regexp"
|
||
"sort"
|
||
"strings"
|
||
|
||
"github.com/kami/maven/internal/router/semantic"
|
||
)
|
||
|
||
// ─── Seed definitions ────────────────────────────────────────────────────────
|
||
|
||
func allSeeds() []semantic.SemanticSeed {
|
||
var seeds []semantic.SemanticSeed
|
||
seeds = append(seeds, actionSeeds()...)
|
||
seeds = append(seeds, knowledgeSeeds()...)
|
||
seeds = append(seeds, memoryWriteSeeds()...)
|
||
seeds = append(seeds, systemSeeds()...)
|
||
seeds = append(seeds, conversationSeeds()...)
|
||
seeds = append(seeds, uncertainSeeds()...)
|
||
return seeds
|
||
}
|
||
|
||
// ─── ACTION seeds ────────────────────────────────────────────────────────────
|
||
// Derived from: deploy tools (12), HA domains (5), Praxis lifecycle (4),
|
||
// task-status (2). Each seed becomes one independent split group.
|
||
|
||
func actionSeeds() []semantic.SemanticSeed {
|
||
var seeds []semantic.SemanticSeed
|
||
|
||
// Process tools from deploy/mavend.json voice.tools
|
||
// Each tool with its Russian aliases forms one seed family.
|
||
toolSeeds := []struct {
|
||
id string
|
||
family string
|
||
opID string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"act-restart", "act-restart", "restart",
|
||
[]string{"перезапусти", "перезагрузи", "рестарт"},
|
||
[]string{"сервис", "nginx", "docker", "maven"},
|
||
[]string{"homelab", "destructive", "process_tool"}},
|
||
{"act-stop", "act-stop", "stop",
|
||
[]string{"останови", "выключи"},
|
||
[]string{"сервис", "nginx", "bотоbackup"},
|
||
[]string{"homelab", "destructive", "process_tool"}},
|
||
{"act-start", "act-start", "start",
|
||
[]string{"запусти", "старт"},
|
||
[]string{"сервис", "nginx", "бэкап"},
|
||
[]string{"homelab", "process_tool"}},
|
||
{"act-docker-restart", "act-docker-restart", "docker-restart",
|
||
[]string{"перезапусти контейнер", "перезагрузи контейнер"},
|
||
[]string{"maven", "nexus", "redis", "postgres"},
|
||
[]string{"homelab", "destructive", "docker"}},
|
||
{"act-docker-stop", "act-docker-stop", "docker-stop",
|
||
[]string{"останови контейнер"},
|
||
[]string{"maven", "nexus", "redis"},
|
||
[]string{"homelab", "destructive", "docker"}},
|
||
{"act-reboot", "act-reboot", "reboot",
|
||
[]string{"перезагрузи сервер", "перезагрузи хост", "ребут"},
|
||
[]string{},
|
||
[]string{"homelab", "destructive", "system"}},
|
||
{"act-status", "act-status", "status",
|
||
[]string{"покажи статус", "проверь статус", "статус"},
|
||
[]string{"nginx", "docker", "maven", "сервер"},
|
||
[]string{"homelab", "read_only", "process_tool"}},
|
||
{"act-ps", "act-ps", "ps",
|
||
[]string{"покажи контейнеры", "список контейнеров", "что запущено"},
|
||
[]string{},
|
||
[]string{"homelab", "read_only", "docker"}},
|
||
{"act-uptime", "act-uptime", "uptime",
|
||
[]string{"покажи uptime", "аптайм", "как работает сервер"},
|
||
[]string{},
|
||
[]string{"homelab", "read_only", "system"}},
|
||
{"act-disk", "act-disk", "disk",
|
||
[]string{"покажи диск", "сколько места на диске"},
|
||
[]string{},
|
||
[]string{"homelab", "read_only", "system"}},
|
||
{"act-memory", "act-memory", "memory",
|
||
[]string{"покажи память", "свободная память"},
|
||
[]string{},
|
||
[]string{"homelab", "read_only", "system"}},
|
||
{"act-logs", "act-logs", "logs",
|
||
[]string{"покажи логи", "логи", "лог"},
|
||
[]string{"nginx", "system", "docker"},
|
||
[]string{"homelab", "read_only", "process_tool"}},
|
||
}
|
||
|
||
for _, t := range toolSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: t.id,
|
||
Route: semantic.RouteAction,
|
||
Family: t.family,
|
||
OperationID: t.opID,
|
||
SplitGroup: t.family,
|
||
VerbForms: t.verbs,
|
||
Subjects: t.objects,
|
||
Tags: t.tags,
|
||
})
|
||
}
|
||
|
||
// Home Assistant operations (when enabled)
|
||
// Each domain+service pair is one seed.
|
||
haSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"ha-light-on", "ha-light-on",
|
||
[]string{"включи свет", "включить свет"},
|
||
[]string{"в спальне", "на кухне", "в гостиной", "в коридоре"},
|
||
[]string{"ha", "light", "turn_on"}},
|
||
{"ha-light-off", "ha-light-off",
|
||
[]string{"выключи свет", "выключить свет"},
|
||
[]string{"в спальне", "на кухне", "в гостиной", "в коридоре"},
|
||
[]string{"ha", "light", "turn_off"}},
|
||
{"ha-switch-on", "ha-switch-on",
|
||
[]string{"включи вытяжку", "включи розетку"},
|
||
[]string{"на кухне", "в ванной"},
|
||
[]string{"ha", "switch", "turn_on"}},
|
||
{"ha-switch-off", "ha-switch-off",
|
||
[]string{"выключи вытяжку", "выключи розетку"},
|
||
[]string{"на кухне", "в ванной"},
|
||
[]string{"ha", "switch", "turn_off"}},
|
||
{"ha-cover-open", "ha-cover-open",
|
||
[]string{"открой жалюзи", "подними жалюзи"},
|
||
[]string{"в спальне", "в гостиной"},
|
||
[]string{"ha", "cover", "open"}},
|
||
{"ha-cover-close", "ha-cover-close",
|
||
[]string{"закрой жалюзи", "опусти жалюзи"},
|
||
[]string{"в спальне", "в гостиной"},
|
||
[]string{"ha", "cover", "close"}},
|
||
{"ha-lock-lock", "ha-lock-lock",
|
||
[]string{"запри дверь", "заблокируй дверь"},
|
||
[]string{"входную", "в гараже"},
|
||
[]string{"ha", "lock", "lock"}},
|
||
{"ha-lock-unlock", "ha-lock-unlock",
|
||
[]string{"отопри дверь", "разблокируй дверь"},
|
||
[]string{"входную", "в гараже"},
|
||
[]string{"ha", "lock", "unlock"}},
|
||
{"ha-fan-on", "ha-fan-on",
|
||
[]string{"включи вентилятор"},
|
||
[]string{"в ванной", "на кухне"},
|
||
[]string{"ha", "fan", "turn_on"}},
|
||
{"ha-fan-off", "ha-fan-off",
|
||
[]string{"выключи вентилятор"},
|
||
[]string{"в ванной", "на кухне"},
|
||
[]string{"ha", "fan", "turn_off"}},
|
||
}
|
||
|
||
for _, h := range haSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: h.id,
|
||
Route: semantic.RouteAction,
|
||
Family: h.family,
|
||
SplitGroup: h.family,
|
||
VerbForms: h.verbs,
|
||
Subjects: h.objects,
|
||
Tags: h.tags,
|
||
})
|
||
}
|
||
|
||
// Praxis lifecycle actions (imperative forms that claim the turn)
|
||
praxisSeeds := []struct {
|
||
id string
|
||
family string
|
||
opID string
|
||
verbs []string
|
||
tags []string
|
||
}{
|
||
{"px-resolve", "praxis-lifecycle", "resolve_item",
|
||
[]string{"закрой", "закрыть", "resolve", "close"},
|
||
[]string{"praxis", "lifecycle"}},
|
||
{"px-acknowledge", "praxis-lifecycle", "acknowledge_item",
|
||
[]string{"принято", "принять", "acknowledge", "ack"},
|
||
[]string{"praxis", "lifecycle"}},
|
||
{"px-ignore", "praxis-lifecycle", "ignore_item",
|
||
[]string{"игнорируй", "игнорировать", "пропусти", "ignore", "skip"},
|
||
[]string{"praxis", "lifecycle"}},
|
||
{"px-pin", "praxis-lifecycle", "pin_item",
|
||
[]string{"закрепи", "закрепить", "pin"},
|
||
[]string{"praxis", "lifecycle"}},
|
||
{"px-attention", "praxis-attention", "list_attention",
|
||
[]string{"что требует внимания", "что нового по задачам"},
|
||
[]string{"praxis", "attention"}},
|
||
{"px-changes", "praxis-changes", "list_changes",
|
||
[]string{"что изменилось", "какие изменения"},
|
||
[]string{"praxis", "changes"}},
|
||
}
|
||
|
||
for _, p := range praxisSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: p.id,
|
||
Route: semantic.RouteAction,
|
||
Family: p.family,
|
||
OperationID: p.opID,
|
||
SplitGroup: p.family + ":" + p.opID,
|
||
VerbForms: p.verbs,
|
||
Tags: p.tags,
|
||
})
|
||
}
|
||
|
||
// Task-status operations
|
||
taskSeeds := []struct {
|
||
id string
|
||
family string
|
||
opID string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"ts-done", "task-status", "task_done",
|
||
[]string{"закрой задачу", "заверши задачу", "close the task", "finish the task"},
|
||
[]string{"купить молоко", "оплатить интернет", "починить кран"},
|
||
[]string{"task", "status"}},
|
||
{"ts-drop", "task-status", "task_drop",
|
||
[]string{"убери задачу", "удали задачу", "отмени задачу", "drop the task", "remove the task"},
|
||
[]string{"купить молоко", "оплатить интернет"},
|
||
[]string{"task", "status"}},
|
||
}
|
||
|
||
for _, t := range taskSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: t.id,
|
||
Route: semantic.RouteAction,
|
||
Family: t.family,
|
||
OperationID: t.opID,
|
||
SplitGroup: t.family + ":" + t.opID,
|
||
VerbForms: t.verbs,
|
||
Subjects: t.objects,
|
||
Tags: t.tags,
|
||
})
|
||
}
|
||
|
||
return seeds
|
||
}
|
||
|
||
// ─── KNOWLEDGE seeds ─────────────────────────────────────────────────────────
|
||
// Derived from: query patterns already in the corpus, expanded by domain.
|
||
|
||
func knowledgeSeeds() []semantic.SemanticSeed {
|
||
var seeds []semantic.SemanticSeed
|
||
|
||
// Calendar queries
|
||
calSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"kq-cal-schedule", "knowledge:calendar",
|
||
[]string{"что у меня в календаре", "какие планы", "что стоит в календаре"},
|
||
[]string{"на завтра", "на послезавтра", "на эту неделю", "на следующую неделю"},
|
||
[]string{"calendar"}},
|
||
{"kq-cal-time", "knowledge:calendar-time",
|
||
[]string{"во сколько встреча", "когда планёрка", "когда собес"},
|
||
[]string{},
|
||
[]string{"calendar", "temporal"}},
|
||
{"kq-cal-next", "knowledge:calendar-next",
|
||
[]string{"что дальше", "что дальше по плану"},
|
||
[]string{},
|
||
[]string{"calendar", "hard"}},
|
||
}
|
||
|
||
for _, c := range calSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: c.id,
|
||
Route: semantic.RouteKnowledge,
|
||
Family: c.family,
|
||
SplitGroup: c.family,
|
||
VerbForms: c.verbs,
|
||
Subjects: c.objects,
|
||
Tags: c.tags,
|
||
})
|
||
}
|
||
|
||
// Recall/personal data queries
|
||
recallSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"kq-recall-fact", "knowledge:recall-fact",
|
||
[]string{"сколько воды я выпил", "сколько раз я ел", "я сегодня пил воду"},
|
||
[]string{},
|
||
[]string{"recall", "aggregate"}},
|
||
{"kq-recall-note", "knowledge:recall-note",
|
||
[]string{"что я записывал про", "какие заметки я оставил про"},
|
||
[]string{"кота", "полив", "сервер", "vlan"},
|
||
[]string{"recall"}},
|
||
{"kq-recall-temporal", "knowledge:recall-temporal",
|
||
[]string{"во сколько я лёг", "когда я в последний раз принимал", "давно я не тренировался"},
|
||
[]string{},
|
||
[]string{"recall", "temporal", "hard"}},
|
||
{"kq-recall-possessive", "knowledge:recall-possessive",
|
||
[]string{"какой у меня любимый", "мой вес за последний", "что у меня"},
|
||
[]string{"язык", "месяц", "в календаре"},
|
||
[]string{"recall", "possessive"}},
|
||
}
|
||
|
||
for _, r := range recallSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: r.id,
|
||
Route: semantic.RouteKnowledge,
|
||
Family: r.family,
|
||
SplitGroup: r.family,
|
||
VerbForms: r.verbs,
|
||
Subjects: r.objects,
|
||
Tags: r.tags,
|
||
})
|
||
}
|
||
|
||
// World knowledge queries
|
||
worldSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"kq-world-def", "knowledge:world-def",
|
||
[]string{"что такое", "кто такой", "что значит"},
|
||
[]string{"TCP", "Docker", "Kubernetes", "Linus Torvalds", "React"},
|
||
[]string{"world", "definition"}},
|
||
{"kq-world-explain", "knowledge:world-explain",
|
||
[]string{"расскажи про", "объясни", "опиши"},
|
||
[]string{"битву при Ватерлоо", "quantum computing", "машинное обучение"},
|
||
[]string{"world", "narrative"}},
|
||
{"kq-world-how", "knowledge:world-how",
|
||
[]string{"как работает", "как настроить", "как починить"},
|
||
[]string{"nginx", "docker", "Git", "SSH"},
|
||
[]string{"world", "howto"}},
|
||
}
|
||
|
||
for _, w := range worldSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: w.id,
|
||
Route: semantic.RouteKnowledge,
|
||
Family: w.family,
|
||
SplitGroup: w.family,
|
||
VerbForms: w.verbs,
|
||
Subjects: w.objects,
|
||
Tags: w.tags,
|
||
})
|
||
}
|
||
|
||
// Homelab queries
|
||
homelabSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"kq-homelab-status", "knowledge:homelab-status",
|
||
[]string{"есть новости по", "что там с", "как дела с"},
|
||
[]string{"бэкапами", "сервером", "доменом", "DNS"},
|
||
[]string{"homelab"}},
|
||
{"kq-homelab-disk", "knowledge:homelab-disk",
|
||
[]string{"хватает ли места", "сколько свободного места"},
|
||
[]string{"под бэкапы", "на диске"},
|
||
[]string{"homelab", "hard"}},
|
||
{"kq-homelab-why", "knowledge:homelab-why",
|
||
[]string{"почему сервер тормозит", "почему не работает"},
|
||
[]string{"nginx", "docker", "DNS"},
|
||
[]string{"homelab", "hard"}},
|
||
}
|
||
|
||
for _, h := range homelabSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: h.id,
|
||
Route: semantic.RouteKnowledge,
|
||
Family: h.family,
|
||
SplitGroup: h.family,
|
||
VerbForms: h.verbs,
|
||
Subjects: h.objects,
|
||
Tags: h.tags,
|
||
})
|
||
}
|
||
|
||
// Aggregate / numeric queries
|
||
aggSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"kq-agg-steps", "knowledge:aggregate",
|
||
[]string{"сколько я прошёл шагов", "покажи шаги за"},
|
||
[]string{"неделю", "месяц", "сегодня"},
|
||
[]string{"aggregate", "health"}},
|
||
{"kq-agg-weight", "knowledge:aggregate-weight",
|
||
[]string{"мой вес", "покажи вес за", "динамика веса"},
|
||
[]string{"за неделю", "за месяц", "за последний месяц"},
|
||
[]string{"aggregate", "health"}},
|
||
{"kq-agg-pressure", "knowledge:aggregate-pressure",
|
||
[]string{"покажи давление за", "мое давление за"},
|
||
[]string{"неделю", "месяц"},
|
||
[]string{"aggregate", "health", "hard"}},
|
||
}
|
||
|
||
for _, a := range aggSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: a.id,
|
||
Route: semantic.RouteKnowledge,
|
||
Family: a.family,
|
||
SplitGroup: a.family,
|
||
VerbForms: a.verbs,
|
||
Subjects: a.objects,
|
||
Tags: a.tags,
|
||
})
|
||
}
|
||
|
||
// Status queries (knowledge about state, not action)
|
||
statusSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"kq-reminder-check", "knowledge:reminder-check",
|
||
[]string{"напоминания на завтра есть", "есть напоминания на"},
|
||
[]string{"завтра", "послезавтра", "эту неделю"},
|
||
[]string{"reminder-shaped", "hard"}},
|
||
{"kq-task-check", "knowledge:task-check",
|
||
[]string{"что у меня по задачам", "какие задачи есть", "покажи задачи"},
|
||
[]string{},
|
||
[]string{"task", "hard"}},
|
||
{"kq-deadline", "knowledge:deadline",
|
||
[]string{"я успеваю до дедлайна", "когда дедлайн"},
|
||
[]string{"по проекту", "по задаче"},
|
||
[]string{"hard", "no-question-word"}},
|
||
}
|
||
|
||
for _, s := range statusSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: s.id,
|
||
Route: semantic.RouteKnowledge,
|
||
Family: s.family,
|
||
SplitGroup: s.family,
|
||
VerbForms: s.verbs,
|
||
Subjects: s.objects,
|
||
Tags: s.tags,
|
||
})
|
||
}
|
||
|
||
// Capability questions (can you do X?)
|
||
capSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"kq-cap-ha", "knowledge:capability-ha",
|
||
[]string{"ты можешь выключить", "умеешь ли включить", "сможешь открыть"},
|
||
[]string{"свет", "жалюзи", "вытяжку", "вентилятор"},
|
||
[]string{"capability_question"}},
|
||
{"kq-cap-tool", "knowledge:capability-tool",
|
||
[]string{"ты можешь перезапустить", "сможешь остановить", "умеешь ли проверить"},
|
||
[]string{"nginx", "docker", "сервер"},
|
||
[]string{"capability_question"}},
|
||
}
|
||
|
||
for _, c := range capSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: c.id,
|
||
Route: semantic.RouteKnowledge,
|
||
Family: c.family,
|
||
SplitGroup: c.family,
|
||
VerbForms: c.verbs,
|
||
Subjects: c.objects,
|
||
Tags: c.tags,
|
||
})
|
||
}
|
||
|
||
return seeds
|
||
}
|
||
|
||
// ─── MEMORY_WRITE seeds ──────────────────────────────────────────────────────
|
||
// Derived from: fact keys (5), note capture verbs, free-form storage patterns.
|
||
|
||
func memoryWriteSeeds() []semantic.SemanticSeed {
|
||
var seeds []semantic.SemanticSeed
|
||
|
||
// Fact writes — one seed per fact key family
|
||
factSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"mw-fact-water", "fact:water",
|
||
[]string{"выпил воды", "воды попил", "пил воду", "just drank water"},
|
||
[]string{"кружку", "стакан", "литр", "два литра"},
|
||
[]string{"fact", "water"}},
|
||
{"mw-fact-meal", "fact:meal",
|
||
[]string{"позавтракал", "пообедал", "поужинал", "ел", "just ate"},
|
||
[]string{"овсянкой", "супом", "салатом", "пиццей"},
|
||
[]string{"fact", "meal"}},
|
||
{"mw-fact-sleep", "fact:sleep",
|
||
[]string{"поспал", "спал", "slept", "just slept"},
|
||
[]string{"часов пять", "семь часов", "час", "полчаса"},
|
||
[]string{"fact", "sleep"}},
|
||
{"mw-fact-shower", "fact:shower",
|
||
[]string{"сходил в душ", "принял душ", "took a shower"},
|
||
[]string{},
|
||
[]string{"fact", "shower"}},
|
||
{"mw-fact-break", "fact:break",
|
||
[]string{"отдохнул", "передохнул", "took a break"},
|
||
[]string{"минут двадцать", "час", "пять минут"},
|
||
[]string{"fact", "break"}},
|
||
}
|
||
|
||
for _, f := range factSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: f.id,
|
||
Route: semantic.RouteMemoryWrite,
|
||
Family: f.family,
|
||
SplitGroup: f.family,
|
||
VerbForms: f.verbs,
|
||
Subjects: f.objects,
|
||
Tags: f.tags,
|
||
})
|
||
}
|
||
|
||
// Unparsed-key facts (facts with keys not in the closed parser)
|
||
unparsedSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"mw-fact-weight", "fact:weight",
|
||
[]string{"запиши вес", "отметь вес", "мой вес"},
|
||
[]string{"74 килограмма", "75 кг", "80 kilograms"},
|
||
[]string{"fact", "unparsed-key"}},
|
||
{"mw-fact-pills", "fact:pills",
|
||
[]string{"отметь что я выпил таблетки", "принял таблетки"},
|
||
[]string{"утром", "вечером", "сегодня"},
|
||
[]string{"fact", "unparsed-key"}},
|
||
{"mw-fact-exercise", "fact:exercise",
|
||
[]string{"сделал зарядку", "потренировался", "just worked out"},
|
||
[]string{"двадцать минут", "час", "полчаса"},
|
||
[]string{"fact", "unparsed-key"}},
|
||
}
|
||
|
||
for _, u := range unparsedSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: u.id,
|
||
Route: semantic.RouteMemoryWrite,
|
||
Family: u.family,
|
||
SplitGroup: u.family,
|
||
VerbForms: u.verbs,
|
||
Subjects: u.objects,
|
||
Tags: u.tags,
|
||
})
|
||
}
|
||
|
||
// Note capture — explicit capture verbs with note body
|
||
noteSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"mw-note-explicit", "note:explicit",
|
||
[]string{"запиши что", "заметка:", "запомни что", "note:"},
|
||
[]string{"кран на кухне капает", "домен продлить в августе", "сосед просил номер электрика"},
|
||
[]string{"note", "capture"}},
|
||
{"mw-note-idea", "note:idea",
|
||
[]string{"запиши идею:", "идея:", "记住:"},
|
||
[]string{"гидропоника на балконе", "сервер в шкаф", "новый проект"},
|
||
[]string{"note", "idea"}},
|
||
{"mw-note-homelab", "note:homelab",
|
||
[]string{"заметка про", "запиши про настройку"},
|
||
[]string{"vlan на свитче", "DNS записи", "备份策略"},
|
||
[]string{"note", "homelab"}},
|
||
{"mw-note-task", "note:task",
|
||
[]string{"добавь в задачи", "запиши задачу"},
|
||
[]string{"купить молоко", "починить кран", "обновить сервер"},
|
||
[]string{"note", "capture", "task"}},
|
||
}
|
||
|
||
for _, n := range noteSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: n.id,
|
||
Route: semantic.RouteMemoryWrite,
|
||
Family: n.family,
|
||
SplitGroup: n.family,
|
||
VerbForms: n.verbs,
|
||
Subjects: n.objects,
|
||
Tags: n.tags,
|
||
})
|
||
}
|
||
|
||
// Free-form remember/store requests
|
||
freeSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"mw-free-remember", "free:remember",
|
||
[]string{"запомни", "сохрани", "занеси", "внеси"},
|
||
[]string{"что встреча в 3", "пароль от wifi", "адрес электрика"},
|
||
[]string{"free_form", "remember"}},
|
||
{"mw-free-state", "free:state",
|
||
[]string{"я чувствую себя", "у меня болит", "я устал"},
|
||
[]string{"хорошо", "голова", "сегодня"},
|
||
[]string{"free_form", "personal_state"}},
|
||
}
|
||
|
||
for _, f := range freeSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: f.id,
|
||
Route: semantic.RouteMemoryWrite,
|
||
Family: f.family,
|
||
SplitGroup: f.family,
|
||
VerbForms: f.verbs,
|
||
Subjects: f.objects,
|
||
Tags: f.tags,
|
||
})
|
||
}
|
||
|
||
return seeds
|
||
}
|
||
|
||
// ─── SYSTEM seeds ────────────────────────────────────────────────────────────
|
||
// Derived from: quiet mode, time/date, self-management.
|
||
|
||
func systemSeeds() []semantic.SemanticSeed {
|
||
var seeds []semantic.SemanticSeed
|
||
|
||
// Quiet mode
|
||
quietSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
tags []string
|
||
}{
|
||
{"sys-quiet-on", "system:quiet-on",
|
||
[]string{"тихий режим", "режим тишина", "будь потише", "говори тихий", "quiet mode", "quiet on"},
|
||
[]string{"quiet"}},
|
||
{"sys-quiet-off", "system:quiet-off",
|
||
[]string{"хватит тихого режима", "громкий режим", "выключи тихий", "quiet off", "quiet end"},
|
||
[]string{"quiet", "hard"}},
|
||
}
|
||
|
||
for _, q := range quietSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: q.id,
|
||
Route: semantic.RouteSystem,
|
||
Family: q.family,
|
||
SplitGroup: q.family,
|
||
VerbForms: q.verbs,
|
||
Tags: q.tags,
|
||
})
|
||
}
|
||
|
||
// Time queries
|
||
timeSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"sys-time-now", "system:time-now",
|
||
[]string{"сколько времени", "который час", "what time is it"},
|
||
[]string{"сейчас", "в киеве", "в москве"},
|
||
[]string{"time"}},
|
||
{"sys-date-today", "system:date-today",
|
||
[]string{"какое число", "какой сегодня день", "what's the date"},
|
||
[]string{"сегодня", "завтра", "послезавтра"},
|
||
[]string{"date"}},
|
||
{"sys-weekday", "system:weekday",
|
||
[]string{"какой день недели", "какой день"},
|
||
[]string{"сегодня", "завтра", "послезавтра", "в субботу"},
|
||
[]string{"date"}},
|
||
}
|
||
|
||
for _, t := range timeSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: t.id,
|
||
Route: semantic.RouteSystem,
|
||
Family: t.family,
|
||
SplitGroup: t.family,
|
||
VerbForms: t.verbs,
|
||
Subjects: t.objects,
|
||
Tags: t.tags,
|
||
})
|
||
}
|
||
|
||
// Additional system seeds for coverage
|
||
extraSystem := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"sys-timezone", "system:timezone",
|
||
[]string{"какой часовой пояс", "часовой пояс", "what timezone"},
|
||
[]string{},
|
||
[]string{"time", "config"}},
|
||
{"sys-self-version", "system:self-version",
|
||
[]string{"какая версия", "текущая версия", "what version"},
|
||
[]string{"maven", "нексуса", "праксиса"},
|
||
[]string{"self", "version"}},
|
||
{"sys-self-status", "system:self-status",
|
||
[]string{"как дела", "как ты", "how are you"},
|
||
[]string{},
|
||
[]string{"self", "greeting"}},
|
||
}
|
||
|
||
for _, s := range extraSystem {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: s.id,
|
||
Route: semantic.RouteSystem,
|
||
Family: s.family,
|
||
SplitGroup: s.family,
|
||
VerbForms: s.verbs,
|
||
Subjects: s.objects,
|
||
Tags: s.tags,
|
||
})
|
||
}
|
||
|
||
return seeds
|
||
}
|
||
|
||
// ─── CONVERSATION seeds ──────────────────────────────────────────────────────
|
||
|
||
func conversationSeeds() []semantic.SemanticSeed {
|
||
var seeds []semantic.SemanticSeed
|
||
|
||
convSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
objects []string
|
||
tags []string
|
||
}{
|
||
{"conv-greeting", "conversation:greeting",
|
||
[]string{"привет", "доброе утро", "добрый день", "добрый вечер", "hello", "good morning"},
|
||
nil,
|
||
[]string{"greeting"}},
|
||
{"conv-mood", "conversation:mood",
|
||
[]string{"мне грустно", "я рад", "я устал сегодня", "у меня плохое настроение", "i had a rough day"},
|
||
nil,
|
||
[]string{"mood"}},
|
||
{"conv-joke", "conversation:joke",
|
||
[]string{"расскажи анекдот", "шутка", "tell me a joke"},
|
||
nil,
|
||
[]string{"joke"}},
|
||
{"conv-thanks", "conversation:thanks",
|
||
[]string{"спасибо", "благодарю", "thanks", "thank you"},
|
||
nil,
|
||
[]string{"thanks"}},
|
||
{"conv-opinion", "conversation:opinion",
|
||
[]string{"что думаешь про", "мне кажется", "как считаешь"},
|
||
[]string{"переезд", "новый проект", "обо мне"},
|
||
[]string{"open_ended"}},
|
||
{"conv-greeting-formal", "conversation:greeting-formal",
|
||
[]string{"здравствуй", "здравствуйте", "hi", "hey"},
|
||
nil,
|
||
[]string{"greeting"}},
|
||
{"conv-goodbye", "conversation:goodbye",
|
||
[]string{"пока", "до свидания", "спокойной ночи", "bye", "goodbye", "good night"},
|
||
nil,
|
||
[]string{"goodbye"}},
|
||
{"conv-sorry", "conversation:sorry",
|
||
[]string{"извини", "прости", "извините", "sorry"},
|
||
nil,
|
||
[]string{"apology"}},
|
||
}
|
||
|
||
for _, c := range convSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: c.id,
|
||
Route: semantic.RouteConversation,
|
||
Family: c.family,
|
||
SplitGroup: c.family,
|
||
VerbForms: c.verbs,
|
||
Tags: c.tags,
|
||
})
|
||
}
|
||
|
||
return seeds
|
||
}
|
||
|
||
// ─── UNCERTAIN seeds ─────────────────────────────────────────────────────────
|
||
|
||
func uncertainSeeds() []semantic.SemanticSeed {
|
||
var seeds []semantic.SemanticSeed
|
||
|
||
uncSeeds := []struct {
|
||
id string
|
||
family string
|
||
verbs []string
|
||
tags []string
|
||
}{
|
||
{"unc-ambiguous-noun", "uncertain:ambiguous-noun",
|
||
[]string{"вода", "бэкап", "сервер", "контейнер", "задача"},
|
||
[]string{"ambiguous"}},
|
||
{"unc-fragment", "uncertain:fragment",
|
||
[]string{"ну это", "потом", "та штука", "the thing from earlier"},
|
||
[]string{"ambiguous", "filler"}},
|
||
{"unc-anaphora", "uncertain:anaphora",
|
||
[]string{"сделай это", "а можно то", "давай那"},
|
||
[]string{"ambiguous", "anaphora"}},
|
||
{"unc-incomplete-reminder", "uncertain:incomplete-reminder",
|
||
[]string{"напомни", "ну напомни же", "надо напомнить"},
|
||
[]string{"ambiguous", "reminder"}},
|
||
{"unc-unclear-action", "uncertain:unclear-action",
|
||
[]string{"ну надо бы", "можно это", "а потом"},
|
||
[]string{"ambiguous", "filler"}},
|
||
{"unc-single-word-verb", "uncertain:single-word-verb",
|
||
[]string{"перезапусти", "выключи", "включи"},
|
||
[]string{"ambiguous", "incomplete"}},
|
||
{"unc-referral", "uncertain:referral",
|
||
[]string{"то что я говорил", "про это", "из предыдущего"},
|
||
[]string{"ambiguous", "anaphora"}},
|
||
{"unc-hedge", "uncertain:hedge",
|
||
[]string{"может быть", "наверное", "кажется"},
|
||
[]string{"ambiguous", "hedge"}},
|
||
{"unc-partial-sentence", "uncertain:partial-sentence",
|
||
[]string{"я хотел бы", "может можно", "а если"},
|
||
[]string{"ambiguous", "incomplete"}},
|
||
{"unc-trailing-off", "uncertain:trailing-off",
|
||
[]string{"вот надо бы", "а потом еще", "и еще"},
|
||
[]string{"ambiguous", "filler"}},
|
||
{"unc-vague-reference", "uncertain:vague-reference",
|
||
[]string{"та самая", "вон та", "прошлый раз"},
|
||
[]string{"ambiguous", "anaphora"}},
|
||
{"unc-multi-ambiguous", "uncertain:multi-ambiguous",
|
||
[]string{"ну как обычно", "всё ок", "нормально вроде"},
|
||
[]string{"ambiguous", "filler"}},
|
||
}
|
||
|
||
for _, u := range uncSeeds {
|
||
seeds = append(seeds, semantic.SemanticSeed{
|
||
ID: u.id,
|
||
Route: semantic.RouteUncertain,
|
||
Family: u.family,
|
||
SplitGroup: u.family,
|
||
VerbForms: u.verbs,
|
||
Tags: u.tags,
|
||
})
|
||
}
|
||
|
||
return seeds
|
||
}
|
||
|
||
// ─── Surface generators ──────────────────────────────────────────────────────
|
||
|
||
// generatorDirect generates direct imperative forms.
|
||
func generatorDirect(seed semantic.SemanticSeed) []semantic.GeneratedSurface {
|
||
var surfaces []semantic.GeneratedSurface
|
||
for _, verb := range seed.VerbForms {
|
||
for _, subj := range seed.Subjects {
|
||
if subj == "" {
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: verb,
|
||
TemplateCategory: "direct_imperative",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
} else {
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: verb + " " + subj,
|
||
TemplateCategory: "direct_imperative",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
}
|
||
}
|
||
if len(seed.Subjects) == 0 {
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: verb,
|
||
TemplateCategory: "direct_imperative",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
}
|
||
}
|
||
return surfaces
|
||
}
|
||
|
||
// generatorPolite adds "пожалуйста" / "please".
|
||
func generatorPolite(seed semantic.SemanticSeed) []semantic.GeneratedSurface {
|
||
var surfaces []semantic.GeneratedSurface
|
||
for _, verb := range seed.VerbForms {
|
||
for _, subj := range seed.Subjects {
|
||
text := verb
|
||
if subj != "" {
|
||
text = verb + " " + subj
|
||
}
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: text + ", пожалуйста",
|
||
TemplateCategory: "polite_request",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
if len(seed.Subjects) == 0 {
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: text + ", please",
|
||
TemplateCategory: "polite_request",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
}
|
||
}
|
||
if len(seed.Subjects) == 0 {
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: verb + ", пожалуйста",
|
||
TemplateCategory: "polite_request",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
}
|
||
}
|
||
return surfaces
|
||
}
|
||
|
||
// generatorModal generates "можешь ...?" / "can you ...?" forms.
|
||
// For action seeds, polite modal = action. For knowledge, modal = knowledge.
|
||
func generatorModal(seed semantic.SemanticSeed) []semantic.GeneratedSurface {
|
||
var surfaces []semantic.GeneratedSurface
|
||
for _, verb := range seed.VerbForms {
|
||
for _, subj := range seed.Subjects {
|
||
text := verb
|
||
if subj != "" {
|
||
text = verb + " " + subj
|
||
}
|
||
// Modal request with explicit intent → action (if executable)
|
||
if seed.Route == semantic.RouteAction {
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: "можешь " + text + ", пожалуйста",
|
||
TemplateCategory: "modal_request",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: "can you " + text + ", please",
|
||
TemplateCategory: "modal_request",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
}
|
||
}
|
||
if len(seed.Subjects) == 0 {
|
||
if seed.Route == semantic.RouteAction {
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: "можешь " + verb + ", пожалуйста",
|
||
TemplateCategory: "modal_request",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
}
|
||
}
|
||
}
|
||
return surfaces
|
||
}
|
||
|
||
// generatorFirstPerson generates "я хочу ...", "надо бы ...", "давай ...".
|
||
func generatorFirstPerson(seed semantic.SemanticSeed) []semantic.GeneratedSurface {
|
||
var surfaces []semantic.GeneratedSurface
|
||
for _, verb := range seed.VerbForms {
|
||
for _, subj := range seed.Subjects {
|
||
text := verb
|
||
if subj != "" {
|
||
text = verb + " " + subj
|
||
}
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: "я хочу " + text,
|
||
TemplateCategory: "first_person_request",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: "надо бы " + text,
|
||
TemplateCategory: "first_person_request",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
}
|
||
if len(seed.Subjects) == 0 {
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: "я хочу " + verb,
|
||
TemplateCategory: "first_person_request",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
}
|
||
}
|
||
return surfaces
|
||
}
|
||
|
||
// generatorReordered puts the target before the verb.
|
||
func generatorReordered(seed semantic.SemanticSeed) []semantic.GeneratedSurface {
|
||
var surfaces []semantic.GeneratedSurface
|
||
for _, verb := range seed.VerbForms {
|
||
for _, subj := range seed.Subjects {
|
||
if subj == "" {
|
||
continue
|
||
}
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: subj + " " + verb,
|
||
TemplateCategory: "reordered_target",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
}
|
||
}
|
||
return surfaces
|
||
}
|
||
|
||
// generatorEnglishDirect generates English equivalents.
|
||
func generatorEnglishDirect(seed semantic.SemanticSeed) []semantic.GeneratedSurface {
|
||
var surfaces []semantic.GeneratedSurface
|
||
// Only generate for seeds that have English verb forms
|
||
for _, verb := range seed.VerbForms {
|
||
if isEnglish(verb) {
|
||
for _, subj := range seed.Subjects {
|
||
text := verb
|
||
if subj != "" {
|
||
text = verb + " " + subj
|
||
}
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: text,
|
||
TemplateCategory: "english_direct",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
}
|
||
if len(seed.Subjects) == 0 {
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: verb,
|
||
TemplateCategory: "english_direct",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
}
|
||
}
|
||
}
|
||
return surfaces
|
||
}
|
||
|
||
// generatorQuestion generates question forms for knowledge seeds.
|
||
func generatorQuestion(seed semantic.SemanticSeed) []semantic.GeneratedSurface {
|
||
var surfaces []semantic.GeneratedSurface
|
||
if seed.Route != semantic.RouteKnowledge {
|
||
return nil
|
||
}
|
||
for _, verb := range seed.VerbForms {
|
||
for _, subj := range seed.Subjects {
|
||
text := verb
|
||
if subj != "" {
|
||
text = verb + " " + subj
|
||
}
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: text + "?",
|
||
TemplateCategory: "question",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
}
|
||
if len(seed.Subjects) == 0 {
|
||
surfaces = append(surfaces, semantic.GeneratedSurface{
|
||
Text: verb + "?",
|
||
TemplateCategory: "question",
|
||
ExpectedRoute: seed.Route,
|
||
})
|
||
}
|
||
}
|
||
return surfaces
|
||
}
|
||
|
||
// ─── Fast-path classifier ────────────────────────────────────────────────────
|
||
// Simplified pattern matcher that mirrors stage-0 grammar outcomes.
|
||
|
||
var (
|
||
reminderVerbRe = regexp.MustCompile(`(?i)^\s*(напомни|напомните|напомнить|напоминай|разбуди|разбудите|разбудить|буди|remind|wake)\b`)
|
||
timeQueryRe = regexp.MustCompile(`(?i)^\s*(сколько\s+сейчас\s+времени|который\s+час|какое\s+число|какой\s+день|what\s+time|what's\s+the\s+date)\b`)
|
||
captureVerbRe = regexp.MustCompile(`(?i)^\s*(запиши|запомни|отметь|заметь|добавь|сохрани|занеси|внеси|note|remember|log|save|add)\b`)
|
||
praxisItemRe = regexp.MustCompile(`(?i)\b(item[_-][a-z0-9_-]+)`)
|
||
quietOnRe = regexp.MustCompile(`(?i)(тихий\s+режим|режим\s+тишина|тише|потише|quiet\s+(mode|on))`)
|
||
quietOffRe = regexp.MustCompile(`(?i)(хватит\s+тихого|громкий\s+режим|выключи\s+тихий|quiet\s+(off|end))`)
|
||
taskDoneRe = regexp.MustCompile(`(?i)^\s*(закрой\s+задачу|заверши\s+задачу|close\s+the\s+task|finish\s+the\s+task)\b`)
|
||
taskDropRe = regexp.MustCompile(`(?i)^\s*(убери\s+задачу|удали\s+задачу|отмени\s+задачу|drop\s+the\s+task|remove\s+the\s+task)\b`)
|
||
)
|
||
|
||
// tool aliases → fast-path matchers (subset of what DefaultActMatcher would match)
|
||
var toolAliasRe = []*regexp.Regexp{
|
||
regexp.MustCompile(`(?i)^\s*(перезапусти|перезагрузи|рестарт)\b`),
|
||
regexp.MustCompile(`(?i)^\s*(останови|выключи)\b`),
|
||
regexp.MustCompile(`(?i)^\s*(запусти|старт)\b`),
|
||
regexp.MustCompile(`(?i)^\s*(перезапусти\s+контейнер|перезагрузи\s+контейнер)\b`),
|
||
regexp.MustCompile(`(?i)^\s*(останови\s+контейнер)\b`),
|
||
regexp.MustCompile(`(?i)^\s*(перезагрузи\s+сервер|перезагрузи\s+хост|ребут)\b`),
|
||
regexp.MustCompile(`(?i)^\s*(покажи\s+статус|проверь\s+статус|статус)\b`),
|
||
regexp.MustCompile(`(?i)^\s*(покажи\s+контейнеры|список\s+контейнеров|что\s+запущено)\b`),
|
||
regexp.MustCompile(`(?i)^\s*(покажи\s+uptime|аптайм|как\s+работает\s+сервер)\b`),
|
||
regexp.MustCompile(`(?i)^\s*(покажи\s+диск|сколько\s+места\s+на\s+диске)\b`),
|
||
regexp.MustCompile(`(?i)^\s*(покажи\s+память|свободная\s+память)\b`),
|
||
regexp.MustCompile(`(?i)^\s*(покажи\s+логи|логи|лог)\b`),
|
||
}
|
||
|
||
// praxis lifecycle verbs (bare, without item reference → residual action)
|
||
var praxisLifecycleRe = regexp.MustCompile(`(?i)^\s*(закрой|закрыть|resolve|close|принято|принять|acknowledge|ack|игнорируй|игнорировать|пропусти|ignore|skip|закрепи|закрепить|pin)\b`)
|
||
var praxisAttentionRe = regexp.MustCompile(`(?i)^\s*(что\s+требует\s+внимания|что\s+нового\s+по\s+(задачам|проектам|сервисам)|needs\s+attention)\b`)
|
||
var praxisChangesRe = regexp.MustCompile(`(?i)^\s*(что\s+изменилось|какие\s+изменения|changed|changes)\b`)
|
||
var praxisEntityRe = regexp.MustCompile(`(?i)^\s*(статус|status|как\s+дела\s+у|how\s+is)\s+`)
|
||
|
||
// classifyFastPath determines whether a surface would be handled by stage-0.
|
||
func classifyFastPath(text string) bool {
|
||
t := strings.TrimSpace(text)
|
||
|
||
// Reminder verbs → always fast-path
|
||
if reminderVerbRe.MatchString(t) {
|
||
return true
|
||
}
|
||
// Time/date queries → fast-path
|
||
if timeQueryRe.MatchString(t) {
|
||
return true
|
||
}
|
||
// Task-status commands → fast-path
|
||
if taskDoneRe.MatchString(t) || taskDropRe.MatchString(t) {
|
||
return true
|
||
}
|
||
// Tool aliases → fast-path (only for verbs alone, not when combined with objects in ways the matcher wouldn't handle)
|
||
for _, re := range toolAliasRe {
|
||
if re.MatchString(t) {
|
||
return true
|
||
}
|
||
}
|
||
// Praxis lifecycle with item reference → fast-path
|
||
if praxisLifecycleRe.MatchString(t) && praxisItemRe.MatchString(t) {
|
||
return true
|
||
}
|
||
// Praxis attention/changes → fast-path
|
||
if praxisAttentionRe.MatchString(t) || praxisChangesRe.MatchString(t) {
|
||
return true
|
||
}
|
||
// Praxis entity attention → fast-path
|
||
if praxisEntityRe.MatchString(t) {
|
||
return true
|
||
}
|
||
// Quiet mode → fast-path (resolved pre-route)
|
||
if quietOnRe.MatchString(t) || quietOffRe.MatchString(t) {
|
||
return true
|
||
}
|
||
// Capture verbs → some are fast-path (note capture)
|
||
if captureVerbRe.MatchString(t) {
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
// ─── Helpers ─────────────────────────────────────────────────────────────────
|
||
|
||
func isEnglish(s string) bool {
|
||
for _, r := range s {
|
||
if r > 127 {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
func normalizeText(s string) string {
|
||
return strings.TrimSpace(strings.ToLower(s))
|
||
}
|
||
|
||
// ─── Corpus building ─────────────────────────────────────────────────────────
|
||
|
||
type corpusEnvelope struct {
|
||
SchemaVersion int `json:"schema_version"`
|
||
Name string `json:"name"`
|
||
Notes []string `json:"notes"`
|
||
Reproducibility *reproMeta `json:"reproducibility,omitempty"`
|
||
Examples []semantic.RouteExample `json:"examples"`
|
||
}
|
||
|
||
type reproMeta struct {
|
||
SourceFixtureHash string `json:"source_fixture_hash"`
|
||
ContrastGeneratorVersion string `json:"contrast_generator_version"`
|
||
SplitAlgorithm string `json:"split_algorithm"`
|
||
DatasetHash string `json:"dataset_hash"`
|
||
}
|
||
|
||
func buildCorpus(seeds []semantic.SemanticSeed) []semantic.RouteExample {
|
||
generators := []semantic.SurfaceGenerator{
|
||
{Name: "direct", Fn: generatorDirect},
|
||
{Name: "polite", Fn: generatorPolite},
|
||
{Name: "modal", Fn: generatorModal},
|
||
{Name: "first_person", Fn: generatorFirstPerson},
|
||
{Name: "reordered", Fn: generatorReordered},
|
||
{Name: "english_direct", Fn: generatorEnglishDirect},
|
||
{Name: "question", Fn: generatorQuestion},
|
||
}
|
||
|
||
seen := make(map[string]bool) // normalized text → seen
|
||
var examples []semantic.RouteExample
|
||
exampleCounter := 0
|
||
|
||
for _, seed := range seeds {
|
||
// Track surfaces within this seed for dedup
|
||
seedSeen := make(map[string]bool)
|
||
|
||
for _, gen := range generators {
|
||
surfaces := gen.Fn(seed)
|
||
for _, surf := range surfaces {
|
||
norm := normalizeText(surf.Text)
|
||
if norm == "" {
|
||
continue
|
||
}
|
||
// Dedup within seed
|
||
if seedSeen[norm] {
|
||
continue
|
||
}
|
||
// Dedup across corpus
|
||
if seen[norm] {
|
||
continue
|
||
}
|
||
seedSeen[norm] = true
|
||
seen[norm] = true
|
||
|
||
exampleCounter++
|
||
srcID := fmt.Sprintf("%s-%03d", seed.ID, exampleCounter)
|
||
|
||
fp := classifyFastPath(surf.Text)
|
||
isResidual := !fp
|
||
|
||
tags := append([]string{}, seed.Tags...)
|
||
tags = append(tags, surf.TemplateCategory)
|
||
if isResidual {
|
||
tags = append(tags, "router_residual")
|
||
}
|
||
|
||
var rr *bool
|
||
if isResidual {
|
||
v := true
|
||
rr = &v
|
||
}
|
||
|
||
examples = append(examples, semantic.RouteExample{
|
||
Text: surf.Text,
|
||
Route: seed.Route,
|
||
Source: "corpus_factory_v2",
|
||
SourceID: srcID,
|
||
SplitGroup: seed.SplitGroup,
|
||
Tags: tags,
|
||
FastPathResolved: fp,
|
||
RouterResidual: rr,
|
||
})
|
||
}
|
||
}
|
||
}
|
||
|
||
return examples
|
||
}
|
||
|
||
// ─── Validation ──────────────────────────────────────────────────────────────
|
||
|
||
func validateAndReport(examples []semantic.RouteExample, seeds []semantic.SemanticSeed) {
|
||
routeCounts := make(map[semantic.SemanticRoute]int)
|
||
sourceCounts := make(map[string]int)
|
||
fpCount, resCount := 0, 0
|
||
groupCounts := make(map[string]map[semantic.SemanticRoute]bool) // group → set of routes
|
||
|
||
// Track normalized text → route for conflict detection
|
||
textRoute := make(map[string]semantic.SemanticRoute)
|
||
|
||
for _, e := range examples {
|
||
routeCounts[e.Route]++
|
||
sourceCounts[e.Source]++
|
||
if e.FastPathResolved {
|
||
fpCount++
|
||
} else {
|
||
resCount++
|
||
}
|
||
|
||
if groupCounts[e.SplitGroup] == nil {
|
||
groupCounts[e.SplitGroup] = make(map[semantic.SemanticRoute]bool)
|
||
}
|
||
groupCounts[e.SplitGroup][e.Route] = true
|
||
|
||
norm := normalizeText(e.Text)
|
||
if prev, ok := textRoute[norm]; ok && prev != e.Route {
|
||
log.Printf("CONFLICT: text %q has route %q and %q", norm, prev, e.Route)
|
||
}
|
||
textRoute[norm] = e.Route
|
||
}
|
||
|
||
// Count independent groups per route
|
||
routeGroups := make(map[semantic.SemanticRoute]map[string]bool)
|
||
for group, routes := range groupCounts {
|
||
for route := range routes {
|
||
if routeGroups[route] == nil {
|
||
routeGroups[route] = make(map[string]bool)
|
||
}
|
||
routeGroups[route][group] = true
|
||
}
|
||
}
|
||
|
||
fmt.Fprintf(os.Stderr, "\n=== CORPUS REPORT ===\n")
|
||
fmt.Fprintf(os.Stderr, "Total examples: %d\n", len(examples))
|
||
fmt.Fprintf(os.Stderr, "Fast-path: %d Residual: %d\n", fpCount, resCount)
|
||
fmt.Fprintf(os.Stderr, "\nRoute distribution:\n")
|
||
for _, r := range semantic.AllRoutes {
|
||
fmt.Fprintf(os.Stderr, " %-15s %4d examples %3d independent groups\n",
|
||
r, routeCounts[r], len(routeGroups[r]))
|
||
}
|
||
fmt.Fprintf(os.Stderr, "\nIndependent SplitGroup count: %d\n", len(groupCounts))
|
||
|
||
// Check minimum coverage targets
|
||
targets := map[semantic.SemanticRoute]int{
|
||
semantic.RouteConversation: 8,
|
||
semantic.RouteKnowledge: 12,
|
||
semantic.RouteAction: 12,
|
||
semantic.RouteMemoryWrite: 12,
|
||
semantic.RouteSystem: 8,
|
||
semantic.RouteUncertain: 12,
|
||
}
|
||
fmt.Fprintf(os.Stderr, "\nCoverage targets:\n")
|
||
for _, r := range semantic.AllRoutes {
|
||
actual := len(routeGroups[r])
|
||
target := targets[r]
|
||
status := "OK"
|
||
if actual < target {
|
||
status = fmt.Sprintf("BELOW (need %d)", target)
|
||
}
|
||
fmt.Fprintf(os.Stderr, " %-15s %3d groups target=%d %s\n", r, actual, target, status)
|
||
}
|
||
|
||
// Source distribution
|
||
fmt.Fprintf(os.Stderr, "\nSource distribution:\n")
|
||
for src, count := range sourceCounts {
|
||
fmt.Fprintf(os.Stderr, " %-25s %d\n", src, count)
|
||
}
|
||
}
|
||
|
||
// ─── Main ────────────────────────────────────────────────────────────────────
|
||
|
||
func main() {
|
||
outPath := flag.String("out", "internal/router/semantic/corpus_v2.json", "output JSON path")
|
||
flag.Parse()
|
||
|
||
// 1. Generate seeds
|
||
seeds := allSeeds()
|
||
fmt.Fprintf(os.Stderr, "Seeds: %d\n", len(seeds))
|
||
|
||
// 2. Generate surfaces and build corpus
|
||
examples := buildCorpus(seeds)
|
||
fmt.Fprintf(os.Stderr, "Generated examples: %d\n", len(examples))
|
||
|
||
// 3. Validate
|
||
if err := semantic.ValidateCorpus(examples); err != nil {
|
||
log.Fatalf("corpus validation failed: %v", err)
|
||
}
|
||
fmt.Fprintf(os.Stderr, "Corpus validation: OK\n")
|
||
|
||
// 4. Report
|
||
validateAndReport(examples, seeds)
|
||
|
||
// 5. Compute dataset hash
|
||
texts := make([]string, len(examples))
|
||
for i, e := range examples {
|
||
texts[i] = e.Text
|
||
}
|
||
sort.Strings(texts)
|
||
h := sha256.Sum256([]byte(strings.Join(texts, "\n")))
|
||
datasetHash := hex.EncodeToString(h[:16])
|
||
|
||
// 6. Write JSON
|
||
env := corpusEnvelope{
|
||
SchemaVersion: 1,
|
||
Name: "semantic_coarse_route_v2",
|
||
Notes: []string{
|
||
"Expanded corpus generated by corpus-factory from deterministic seed specifications.",
|
||
"Every row derives from an authoritative Maven capability source — no hand-authored sentences.",
|
||
"fast_path_resolved is set by the fast-path classifier mirroring stage-0 grammar outcomes.",
|
||
"Labels come from seed specifications, not model output.",
|
||
},
|
||
Reproducibility: &reproMeta{
|
||
SourceFixtureHash: "corpus-factory-v2",
|
||
ContrastGeneratorVersion: "v2-direct-generation",
|
||
SplitAlgorithm: "grouped-cv-v1",
|
||
DatasetHash: datasetHash,
|
||
},
|
||
Examples: examples,
|
||
}
|
||
|
||
data, err := json.MarshalIndent(env, "", " ")
|
||
if err != nil {
|
||
log.Fatalf("marshal: %v", err)
|
||
}
|
||
if err := os.WriteFile(*outPath, data, 0644); err != nil {
|
||
log.Fatalf("write %s: %v", *outPath, err)
|
||
}
|
||
fmt.Fprintf(os.Stderr, "\nOutput: %s (%d bytes)\n", *outPath, len(data))
|
||
}
|