descrybe/apps/api/cmd/mock-llm/formula.go

package main

import (
	"encoding/json"
	"fmt"
	"regexp"
	"sort"
	"strings"
)

// Formula-aware local generator.
//
// processing.HeuristicCompleter is the production offline fallback and stays
// deliberately dumb. For local proofs that is not enough: a run only shows the
// category formula works if the reply actually follows the formula in the prompt.
// This reader parses the product template out of the user message and answers with
// copy shaped by it, built ONLY from the supplied name / description / category /
// attrs — never invented facts — which is exactly the contract the pipeline gates
// the real model against.

var (
	reTemplateHeader = regexp.MustCompile(`(?is)(?:GPT predloga|Product template)\s*:\s*(.*?)(?:\n\s*(?:Odgovori SAMO|Reply with ONE)|$)`)
	reNameBlock      = regexp.MustCompile(`(?is)<\s*name\s*>\s*\{?(.*?)\}?\s*<\s*/\s*name\s*>`)
	reMetaBlock      = regexp.MustCompile(`(?is)<\s*metaDescription\s*>\s*\{?(.*?)\}?\s*<\s*/\s*metaDescription\s*>`)
	reBodyBlock      = regexp.MustCompile(`(?is)<\s*(h[1-4]|p|b|ul|li)\s*>\s*\{?(.*?)\}?\s*<\s*/\s*(?:h[1-4]|p|b|ul|li)\s*>`)
	reAttrsLine      = regexp.MustCompile(`(?im)^\s*Attrs:\s*(\{.*\})\s*$`)
	reQuotedSlot     = regexp.MustCompile(`"([^"]+)"`)
)

type formulaBlock struct {
	tag  string
	text string
}

type promptFacts struct {
	name     string
	desc     string
	category string
	attrs    map[string]any
}

// buildFormulaReply returns an enhance JSON reply that satisfies the template in
// user, or ok=false when the prompt carries no template (caller falls back).
func buildFormulaReply(system, user string) (string, bool) {
	m := reTemplateHeader.FindStringSubmatch(user)
	if m == nil {
		return "", false
	}
	tpl := m[1]
	nameRule := ""
	if nm := reNameBlock.FindStringSubmatch(tpl); nm != nil {
		nameRule = strings.TrimSpace(nm[1])
	}
	metaRule := ""
	if mm := reMetaBlock.FindStringSubmatch(tpl); mm != nil {
		metaRule = strings.TrimSpace(mm[1])
	}
	body := reNameBlock.ReplaceAllString(tpl, "")
	body = reMetaBlock.ReplaceAllString(body, "")
	var blocks []formulaBlock
	for _, b := range reBodyBlock.FindAllStringSubmatch(body, -1) {
		tag := strings.ToLower(strings.TrimSpace(b[1]))
		blocks = append(blocks, formulaBlock{tag: tag, text: strings.TrimSpace(b[2])})
	}
	if nameRule == "" && len(blocks) == 0 {
		return "", false
	}

	facts := readPromptFacts(user)
	name := buildFormulaName(nameRule, facts)
	desc := buildFormulaBody(blocks, name, facts)

	payload := map[string]any{
		"name":        name,
		"description": desc,
	}
	if strings.Contains(strings.ToLower(system), "meta_title") && metaRule != "" {
		payload["meta_title"] = truncateRunesLocal(name, 60)
		payload["meta_description"] = truncateRunesLocal(name+" — "+plainText(desc), 155)
	}
	if strings.Contains(strings.ToLower(system), `"attrs"`) {
		payload["attrs"] = facts.attrs
	}
	b, err := json.Marshal(payload)
	if err != nil {
		return "", false
	}
	return string(b), true
}

func readPromptFacts(user string) promptFacts {
	f := promptFacts{attrs: map[string]any{}}
	f.name = labeledLine(user, "Staro_ime_izdelka:", "Old_product_name:", "Name:")
	f.desc = labeledLine(user, "Star_opis_izdelka:", "Old_product_description:", "Description:")
	f.category = labeledLine(user, "Kategorija:", "Category:")
	if m := reAttrsLine.FindStringSubmatch(user); m != nil {
		var attrs map[string]any
		if err := json.Unmarshal([]byte(m[1]), &attrs); err == nil {
			f.attrs = attrs
		}
	}
	return f
}

func labeledLine(user string, labels ...string) string {
	for _, line := range strings.Split(user, "\n") {
		t := strings.TrimSpace(line)
		for _, label := range labels {
			if strings.HasPrefix(t, label) {
				if v := strings.TrimSpace(strings.TrimPrefix(t, label)); v != "" {
					return v
				}
			}
		}
	}
	return ""
}

// buildFormulaName fills the quoted slots of the <name> formula from attrs. Slots
// with no matching attribute are dropped rather than guessed.
func buildFormulaName(nameRule string, f promptFacts) string {
	if nameRule == "" {
		return f.name
	}
	var parts []string
	seen := map[string]bool{}
	for _, m := range reQuotedSlot.FindAllStringSubmatch(nameRule, -1) {
		slot := strings.ToLower(strings.Trim(strings.TrimSpace(m[1]), `",. `))
		if slot == "" {
			continue
		}
		v := valueForSlot(slot, f)
		if v == "" || seen[strings.ToLower(v)] {
			continue
		}
		seen[strings.ToLower(v)] = true
		parts = append(parts, v)
	}
	if len(parts) == 0 {
		return f.name
	}
	return strings.Join(parts, " ")
}

func valueForSlot(slot string, f promptFacts) string {
	switch {
	case strings.Contains(slot, "znamka") || strings.Contains(slot, "brand"):
		return attrString(f.attrs, "brand")
	case strings.Contains(slot, "poln model") || strings.Contains(slot, "product model") ||
		strings.Contains(slot, "model izdelka") || slot == "model":
		return attrString(f.attrs, "product_model", "model", "sku")
	case strings.Contains(slot, "tip izdelka") || strings.Contains(slot, "product type") ||
		strings.Contains(slot, "vrsta izdelka"):
		if v := attrString(f.attrs, "product_type"); v != "" {
			return v
		}
		return singularCategory(f.category)
	case strings.Contains(slot, "barva") || strings.Contains(slot, "colour") || strings.Contains(slot, "color"):
		return attrString(f.attrs, "barva", "color", "colour")
	case strings.Contains(slot, "procesor") || strings.Contains(slot, "processor"):
		return attrString(f.attrs, "procesor", "processor", "cpu")
	case strings.Contains(slot, "pomnilnik") || strings.Contains(slot, "memory"):
		return attrString(f.attrs, "kapaciteta_ram_pomnilnika", "memory", "ram")
	case strings.Contains(slot, "kapaciteta") || strings.Contains(slot, "capacity"):
		return attrString(f.attrs, "kapaciteta", "capacity")
	case strings.Contains(slot, "dimenzij") || strings.Contains(slot, "dimensions"):
		return attrString(f.attrs, "dimensions", "dimenzije")
	case strings.Contains(slot, "diagonal") || strings.Contains(slot, "screen"):
		return attrString(f.attrs, "diagonala_zaslona", "screen_size")
	default:
		return ""
	}
}

func attrString(attrs map[string]any, keys ...string) string {
	for _, k := range keys {
		for ak, av := range attrs {
			if !strings.EqualFold(strings.TrimSpace(ak), k) {
				continue
			}
			if s := strings.TrimSpace(fmt.Sprint(av)); s != "" && s != "<nil>" {
				return s
			}
		}
	}
	return ""
}

func singularCategory(cat string) string {
	c := strings.TrimSpace(cat)
	if c == "" {
		return ""
	}
	return strings.ToLower(c)
}

// buildFormulaBody emits one HTML element per template block, in order, with the
// tag the block asks for. Paragraph text is drawn from the supplied description and
// attributes so the reply stays inside the evidence the prompt provided.
func buildFormulaBody(blocks []formulaBlock, name string, f promptFacts) string {
	sentences := splitSentences(f.desc)
	facts := attrSentences(f.attrs)
	var b strings.Builder
	para := 0
	for _, blk := range blocks {
		instr := strings.ToLower(blk.text)
		switch blk.tag {
		case "h1", "h2", "h3", "h4":
			heading := name
			if strings.Contains(instr, "ne napiši") || strings.Contains(instr, "do not write") ||
				strings.Contains(instr, "brez") || strings.Contains(instr, "without") {
				heading = benefitHeading(f)
			}
			fmt.Fprintf(&b, "<%s>%s</%s>", blk.tag, escapeHTML(heading), blk.tag)
		case "ul", "li":
			items := facts
			if len(items) == 0 {
				items = []string{"Category: " + f.category}
			}
			b.WriteString("<ul>")
			for _, it := range items {
				fmt.Fprintf(&b, "<li>%s</li>", escapeHTML(it))
			}
			b.WriteString("</ul>")
		case "b":
			fmt.Fprintf(&b, "<b>%s</b>", escapeHTML(strings.TrimSpace(blk.text)))
		default: // p
			includeName := strings.Contains(instr, "vključi") || strings.Contains(instr, "does include") ||
				strings.Contains(instr, "include the new product name")
			excludeName := strings.Contains(instr, "ne vsebuje") || strings.Contains(instr, "not contain") ||
				strings.Contains(instr, "not include")
			text := paragraphFor(sentences, para, f)
			if includeName && !excludeName {
				text = name + " — " + text
			}
			fmt.Fprintf(&b, "<p>%s</p>", escapeHTML(text))
			para++
		}
	}
	return b.String()
}

func paragraphFor(sentences []string, idx int, f promptFacts) string {
	if len(sentences) == 0 {
		if c := strings.TrimSpace(f.category); c != "" {
			return "Listed under " + c + " with the details supplied by the supplier feed."
		}
		return "Details as supplied by the supplier feed."
	}
	// Rotate through the supplied sentences so repeated paragraphs differ, then pad
	// with attribute facts to a body length the quality gate accepts.
	var parts []string
	for i := 0; i < len(sentences); i++ {
		parts = append(parts, sentences[(idx+i)%len(sentences)])
	}
	out := strings.Join(parts, " ")
	for _, fact := range attrSentences(f.attrs) {
		if len([]rune(out)) >= 220 {
			break
		}
		out += " " + fact + "."
	}
	return strings.TrimSpace(out)
}

func benefitHeading(f promptFacts) string {
	if c := strings.TrimSpace(f.category); c != "" {
		return "Built for everyday " + strings.ToLower(c)
	}
	return "Built for everyday use"
}

func attrSentences(attrs map[string]any) []string {
	keys := make([]string, 0, len(attrs))
	for k := range attrs {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	out := make([]string, 0, len(keys))
	for _, k := range keys {
		v := strings.TrimSpace(fmt.Sprint(attrs[k]))
		if v == "" || v == "<nil>" {
			continue
		}
		out = append(out, prettyKey(k)+": "+v)
		if len(out) >= 8 {
			break
		}
	}
	return out
}

func prettyKey(k string) string {
	k = strings.ReplaceAll(strings.TrimSpace(k), "_", " ")
	if k == "" {
		return k
	}
	return strings.ToUpper(k[:1]) + k[1:]
}

func splitSentences(s string) []string {
	s = strings.TrimSpace(plainText(s))
	if s == "" {
		return nil
	}
	var out []string
	for _, part := range strings.FieldsFunc(s, func(r rune) bool { return r == '.' || r == '!' || r == '?' }) {
		p := strings.TrimSpace(part)
		if len([]rune(p)) < 3 {
			continue
		}
		out = append(out, p+".")
	}
	return out
}

func plainText(s string) string {
	var b strings.Builder
	inTag := false
	for _, r := range s {
		switch {
		case r == '<':
			inTag = true
		case r == '>':
			inTag = false
		case !inTag:
			b.WriteRune(r)
		}
	}
	return strings.Join(strings.Fields(b.String()), " ")
}

func escapeHTML(s string) string {
	r := strings.NewReplacer("<", "", ">", "", "&", "and")
	return strings.TrimSpace(r.Replace(s))
}

func truncateRunesLocal(s string, n int) string {
	rs := []rune(strings.TrimSpace(s))
	if len(rs) <= n {
		return string(rs)
	}
	return strings.TrimSpace(string(rs[:n]))
}