750 lines
22 KiB
Go
750 lines
22 KiB
Go
package catalog
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"unicode"
|
|
|
|
"github.com/descrybe/descrybe-v2/apps/api/internal/aiprompts"
|
|
"github.com/descrybe/descrybe-v2/apps/api/internal/billing"
|
|
"github.com/descrybe/descrybe-v2/apps/api/internal/company"
|
|
"github.com/descrybe/descrybe-v2/apps/api/internal/security"
|
|
"github.com/google/uuid"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
)
|
|
|
|
// Canonical Postgres id for the migrated A1 Slovenija tenant (seed-a1 default).
|
|
const a1CompanyID = "604f23a8-b66e-4b21-8b45-0d72b68f4790"
|
|
|
|
// platformDemoCompanyName matches migrator / seed-demo standalone demo tenant.
|
|
const platformDemoCompanyName = "Platform Demo"
|
|
|
|
// RepairCategoryEnhancePromptsResult is the dry-run / apply summary for
|
|
// RepairA1DemoCategoryEnhancePrompts.
|
|
type RepairCategoryEnhancePromptsResult struct {
|
|
CompaniesScanned int `json:"companies_scanned"`
|
|
CategoriesSeen int `json:"categories_seen"`
|
|
WouldUpdate int `json:"would_update"`
|
|
Updated int `json:"updated"`
|
|
AlreadyOK int `json:"already_ok"`
|
|
EmptySkipped int `json:"empty_skipped"`
|
|
SeedMatched int `json:"seed_matched"`
|
|
SplitFromLegacy int `json:"split_from_legacy"`
|
|
FallbackTemplate int `json:"fallback_template"`
|
|
TitleTemplateBackfill int `json:"title_template_backfill"`
|
|
DescTemplateBackfill int `json:"description_template_backfill"`
|
|
ByCompany map[string]int `json:"by_company"`
|
|
DryRun bool `json:"dry_run"`
|
|
SeedPath string `json:"seed_path,omitempty"`
|
|
// WPCategoriesPath is set when overlays came from wp_product_categories.sql.
|
|
WPCategoriesPath string `json:"wp_categories_path,omitempty"`
|
|
SeedEntries int `json:"seed_entries,omitempty"`
|
|
}
|
|
|
|
// RepairA1DemoOptions configures optional seed overlay path for legacy splits.
|
|
type RepairA1DemoOptions struct {
|
|
// SeedPromptsPath points at a1-category-prompts.json OR wp_product_categories.sql.
|
|
// Empty → auto-detect WP SQL (SEED_A1_WP_CATEGORIES / scripts/seed), else JSON seed.
|
|
SeedPromptsPath string
|
|
// WPCategoriesPath forces wp_product_categories.sql (overrides SeedPromptsPath when set).
|
|
WPCategoriesPath string
|
|
// WPCategoriesSQL is optional dump bytes (legacy Admin Sync A1 upload / API clients).
|
|
// When non-empty, takes precedence over filesystem auto-detect / path options.
|
|
WPCategoriesSQL []byte
|
|
// ForceFromSeed overwrites already-sectioned prompts when a seed match exists
|
|
// (WP dump / JSON is source of truth). Default true when WP SQL is resolved.
|
|
ForceFromSeed *bool
|
|
}
|
|
|
|
// RepairA1DemoCategoryEnhancePrompts replaces non-sectioned / legacy combined
|
|
// categories.prompt values for A1 Slovenija + Platform Demo with role-sectioned
|
|
// overlays (Title / Description / Meta / Attributes). Prefers wp_product_categories.sql
|
|
// (SEED_A1_WP_CATEGORIES / scripts/seed) as source of truth, then a1-category-prompts.json,
|
|
// splitting combined Name+Description prompts so naming rules land under Title and
|
|
// HTML body under Description; otherwise fall back to CategoryEnhanceUserTemplate.
|
|
//
|
|
// Also repairs empty or brand-only title_template and empty description_template
|
|
// from legacy <name> / HTML / meta blocks so enhance uses real A1 formulas.
|
|
//
|
|
// LOCAL repair only (idempotent when seed unchanged):
|
|
// - Writes JSON-compatible user overlays under both "sl" (prompt->>'sl') and "*"
|
|
// (LangPromptAny) so language stays via {{language}}.
|
|
// - dryRun=true: count WouldUpdate only; dryRun=false: apply and set Updated.
|
|
//
|
|
// Entrypoint: go run ./cmd/repair-category-prompts (-dry-run | -apply).
|
|
func RepairA1DemoCategoryEnhancePrompts(ctx context.Context, pool *pgxpool.Pool, dryRun bool) (RepairCategoryEnhancePromptsResult, error) {
|
|
return RepairA1DemoCategoryEnhancePromptsWithOptions(ctx, pool, dryRun, RepairA1DemoOptions{})
|
|
}
|
|
|
|
// RepairA1DemoCategoryEnhancePromptsWithOptions is RepairA1DemoCategoryEnhancePrompts
|
|
// with an explicit seed / WP dump path.
|
|
func RepairA1DemoCategoryEnhancePromptsWithOptions(ctx context.Context, pool *pgxpool.Pool, dryRun bool, opts RepairA1DemoOptions) (RepairCategoryEnhancePromptsResult, error) {
|
|
out := RepairCategoryEnhancePromptsResult{
|
|
DryRun: dryRun,
|
|
ByCompany: map[string]int{},
|
|
}
|
|
if pool == nil {
|
|
return out, fmt.Errorf("postgres pool is required")
|
|
}
|
|
|
|
if len(opts.WPCategoriesSQL) > 0 {
|
|
if _, _, err := LoadWPCategoryPromptOverlaysFromBytes(opts.WPCategoriesSQL); err != nil {
|
|
return out, fmt.Errorf("wp_product_categories upload: %w", err)
|
|
}
|
|
}
|
|
|
|
a1ID, err := uuid.Parse(a1CompanyID)
|
|
if err != nil {
|
|
return out, fmt.Errorf("a1 company id: %w", err)
|
|
}
|
|
|
|
companyRows, err := pool.Query(ctx, `
|
|
SELECT id, name
|
|
FROM companies
|
|
WHERE id = $1
|
|
OR name = $2
|
|
OR COALESCE(legacy_company_id, '') = $3
|
|
ORDER BY name`, a1ID, platformDemoCompanyName, billing.A1LegacyCompanyID)
|
|
if err != nil {
|
|
return out, fmt.Errorf("list target companies: %w", err)
|
|
}
|
|
defer companyRows.Close()
|
|
|
|
type co struct {
|
|
id uuid.UUID
|
|
name string
|
|
}
|
|
companies := make([]co, 0, 2)
|
|
for companyRows.Next() {
|
|
var c co
|
|
if err := companyRows.Scan(&c.id, &c.name); err != nil {
|
|
return out, err
|
|
}
|
|
companies = append(companies, c)
|
|
}
|
|
if err := companyRows.Err(); err != nil {
|
|
return out, err
|
|
}
|
|
out.CompaniesScanned = len(companies)
|
|
if len(companies) == 0 {
|
|
return out, fmt.Errorf("no A1 / Platform Demo companies found")
|
|
}
|
|
|
|
seedByNorm, seedByUID, seedMeta := resolveCategoryPromptOverlays(opts)
|
|
out.SeedPath = seedMeta.Path
|
|
out.WPCategoriesPath = seedMeta.WPPath
|
|
out.SeedEntries = seedMeta.Entries
|
|
forceFromSeed := seedMeta.ForceFromSeed
|
|
if opts.ForceFromSeed != nil {
|
|
forceFromSeed = *opts.ForceFromSeed
|
|
}
|
|
|
|
for _, c := range companies {
|
|
n, err := repairCompanyCategoryEnhancePrompts(ctx, pool, c.id, c.name, seedByNorm, seedByUID, dryRun, forceFromSeed, &out)
|
|
if err != nil {
|
|
return out, err
|
|
}
|
|
if n > 0 {
|
|
out.ByCompany[c.name] = n
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
type categoryPromptOverlayMeta struct {
|
|
Path string
|
|
WPPath string
|
|
Entries int
|
|
ForceFromSeed bool
|
|
}
|
|
|
|
func resolveCategoryPromptOverlays(opts RepairA1DemoOptions) (byNorm, byUID map[string]string, meta categoryPromptOverlayMeta) {
|
|
byNorm = map[string]string{}
|
|
byUID = map[string]string{}
|
|
|
|
if len(opts.WPCategoriesSQL) > 0 {
|
|
n, u, err := LoadWPCategoryPromptOverlaysFromBytes(opts.WPCategoriesSQL)
|
|
if err == nil {
|
|
meta.Path = "upload:wp_product_categories.sql"
|
|
meta.WPPath = "upload:wp_product_categories.sql"
|
|
meta.Entries = len(n)
|
|
meta.ForceFromSeed = true
|
|
return n, u, meta
|
|
}
|
|
}
|
|
|
|
wpPath := strings.TrimSpace(opts.WPCategoriesPath)
|
|
if wpPath == "" {
|
|
wpPath = ResolveWPCategoryPromptsPath("")
|
|
} else {
|
|
wpPath = ResolveWPCategoryPromptsPath(wpPath)
|
|
}
|
|
if wpPath != "" {
|
|
n, u, err := loadWPCategoryPromptOverlays(wpPath)
|
|
if err == nil {
|
|
meta.Path = wpPath
|
|
meta.WPPath = wpPath
|
|
meta.Entries = len(n)
|
|
meta.ForceFromSeed = true
|
|
return n, u, meta
|
|
}
|
|
}
|
|
|
|
seedPath := strings.TrimSpace(opts.SeedPromptsPath)
|
|
if seedPath == "" {
|
|
seedPath = resolveA1CategoryPromptsPath()
|
|
}
|
|
if seedPath != "" && isWPCategoryPromptsSQLPath(seedPath) {
|
|
n, u, err := loadWPCategoryPromptOverlays(seedPath)
|
|
if err == nil {
|
|
meta.Path = seedPath
|
|
meta.WPPath = seedPath
|
|
meta.Entries = len(n)
|
|
meta.ForceFromSeed = true
|
|
return n, u, meta
|
|
}
|
|
}
|
|
if seedPath != "" {
|
|
n, u, err := loadA1CategoryPromptOverlays(seedPath)
|
|
if err == nil {
|
|
meta.Path = seedPath
|
|
meta.Entries = len(n)
|
|
meta.ForceFromSeed = false
|
|
return n, u, meta
|
|
}
|
|
}
|
|
return byNorm, byUID, meta
|
|
}
|
|
|
|
func resolveA1CategoryPromptsPath() string {
|
|
candidates := []string{
|
|
filepath.Join("scripts", "seed", "a1-category-prompts.json"),
|
|
filepath.Join("..", "..", "scripts", "seed", "a1-category-prompts.json"),
|
|
filepath.Join("..", "..", "..", "scripts", "seed", "a1-category-prompts.json"),
|
|
}
|
|
// Walk up from cwd looking for scripts/seed/a1-category-prompts.json.
|
|
if wd, err := os.Getwd(); err == nil {
|
|
dir := wd
|
|
for i := 0; i < 8; i++ {
|
|
candidates = append(candidates, filepath.Join(dir, "scripts", "seed", "a1-category-prompts.json"))
|
|
parent := filepath.Dir(dir)
|
|
if parent == dir {
|
|
break
|
|
}
|
|
dir = parent
|
|
}
|
|
}
|
|
for _, p := range candidates {
|
|
if st, err := os.Stat(p); err == nil && !st.IsDir() {
|
|
return p
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type a1CategoryPromptFile struct {
|
|
Entries []a1CategoryPromptEntry `json:"entries"`
|
|
}
|
|
|
|
type a1CategoryPromptEntry struct {
|
|
Name string `json:"name"`
|
|
UniqueID string `json:"unique_id,omitempty"`
|
|
Prompt string `json:"prompt"`
|
|
}
|
|
|
|
func loadA1CategoryPromptOverlays(path string) (byNorm map[string]string, byUID map[string]string, err error) {
|
|
byNorm = map[string]string{}
|
|
byUID = map[string]string{}
|
|
path = filepath.Clean(strings.TrimSpace(path))
|
|
if path == "" || path == "." {
|
|
return byNorm, byUID, fmt.Errorf("seed prompts path empty")
|
|
}
|
|
if filepath.Base(path) != "a1-category-prompts.json" {
|
|
return byNorm, byUID, fmt.Errorf("refusing unexpected category prompts file name %q", filepath.Base(path))
|
|
}
|
|
raw, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return byNorm, byUID, err
|
|
}
|
|
if len(raw) > 8<<20 {
|
|
return byNorm, byUID, fmt.Errorf("category prompts file too large (%d bytes)", len(raw))
|
|
}
|
|
var f a1CategoryPromptFile
|
|
if err := json.Unmarshal(raw, &f); err != nil {
|
|
return byNorm, byUID, err
|
|
}
|
|
for _, e := range f.Entries {
|
|
p := strings.TrimSpace(e.Prompt)
|
|
if p == "" {
|
|
continue
|
|
}
|
|
if uid := strings.ToLower(strings.TrimSpace(e.UniqueID)); uid != "" {
|
|
byUID[uid] = p
|
|
}
|
|
if key := normalizeCategoryPromptName(e.Name); key != "" {
|
|
byNorm[key] = p
|
|
}
|
|
}
|
|
if len(byNorm) == 0 && len(byUID) == 0 {
|
|
return byNorm, byUID, fmt.Errorf("no usable seed prompt entries")
|
|
}
|
|
return byNorm, byUID, nil
|
|
}
|
|
|
|
func normalizeCategoryPromptName(s string) string {
|
|
s = strings.TrimSpace(s)
|
|
if s == "" {
|
|
return ""
|
|
}
|
|
s = strings.ToLower(s)
|
|
var b strings.Builder
|
|
b.Grow(len(s))
|
|
prevSpace := false
|
|
for _, r := range s {
|
|
r = foldSlovenePromptRune(r)
|
|
if unicode.IsSpace(r) {
|
|
if prevSpace || b.Len() == 0 {
|
|
continue
|
|
}
|
|
b.WriteByte(' ')
|
|
prevSpace = true
|
|
continue
|
|
}
|
|
prevSpace = false
|
|
if unicode.IsLetter(r) || unicode.IsDigit(r) || r == '-' || r == '/' || r == '&' || r == '+' {
|
|
b.WriteRune(r)
|
|
}
|
|
}
|
|
return strings.TrimSpace(b.String())
|
|
}
|
|
|
|
func foldSlovenePromptRune(r rune) rune {
|
|
switch r {
|
|
case 'č', 'ć':
|
|
return 'c'
|
|
case 'š':
|
|
return 's'
|
|
case 'ž':
|
|
return 'z'
|
|
case 'đ':
|
|
return 'd'
|
|
default:
|
|
return r
|
|
}
|
|
}
|
|
|
|
// repairedCategoryEnhancePromptMap is the shared fallback overlay (no per-category
|
|
// Slovenian rules): "sl" + LangPromptAny ("*").
|
|
func repairedCategoryEnhancePromptMap() (company.LangPromptMap, error) {
|
|
tpl := strings.TrimSpace(aiprompts.CategoryEnhanceUserTemplate)
|
|
if tpl == "" {
|
|
return nil, fmt.Errorf("CategoryEnhanceUserTemplate is empty")
|
|
}
|
|
return company.LangPromptMap{
|
|
"sl": tpl,
|
|
company.LangPromptAny: tpl,
|
|
}, nil
|
|
}
|
|
|
|
func categoryEnhancePromptValueOK(p string) bool {
|
|
p = strings.TrimSpace(p)
|
|
if p == "" {
|
|
return false
|
|
}
|
|
return !aiprompts.CategoryEnhancePromptNeedsRepair(p)
|
|
}
|
|
|
|
func categoryEnhancePromptMapOK(m company.LangPromptMap) bool {
|
|
if !company.HasAnyPrompt(m) {
|
|
return false
|
|
}
|
|
for _, p := range m {
|
|
p = strings.TrimSpace(p)
|
|
if p == "" {
|
|
continue
|
|
}
|
|
if !categoryEnhancePromptValueOK(p) {
|
|
return false
|
|
}
|
|
}
|
|
// Require sl or * present.
|
|
if strings.TrimSpace(m[company.LangPromptAny]) == "" && strings.TrimSpace(m["sl"]) == "" {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func pickSeedPrompt(uniqueID, name string, byNorm, byUID map[string]string) string {
|
|
if uid := strings.ToLower(strings.TrimSpace(uniqueID)); uid != "" {
|
|
if p, ok := byUID[uid]; ok {
|
|
return p
|
|
}
|
|
}
|
|
if key := normalizeCategoryPromptName(name); key != "" {
|
|
if p, ok := byNorm[key]; ok {
|
|
return p
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func resolveRepairedEnhancePrompt(current company.LangPromptMap, seedLegacy string, preferSeed bool, out *RepairCategoryEnhancePromptsResult) string {
|
|
prompt, fromSeed, fromLegacy, fallback := computeRepairedEnhancePrompt(current, seedLegacy, preferSeed)
|
|
if fromSeed {
|
|
out.SeedMatched++
|
|
}
|
|
if fromLegacy {
|
|
out.SplitFromLegacy++
|
|
}
|
|
if fallback {
|
|
out.FallbackTemplate++
|
|
}
|
|
return prompt
|
|
}
|
|
|
|
func computeRepairedEnhancePrompt(current company.LangPromptMap, seedLegacy string, preferSeed bool) (prompt string, fromSeed, fromLegacy, fallback bool) {
|
|
trySeed := func(raw string) (string, bool, bool) {
|
|
raw = strings.TrimSpace(raw)
|
|
if raw == "" {
|
|
return "", false, false
|
|
}
|
|
if aiprompts.IsLegacyCombinedEnhancePrompt(raw) {
|
|
return aiprompts.SplitLegacyCombinedEnhancePrompt(raw), true, false
|
|
}
|
|
if aiprompts.CategoryEnhanceHasRoleSections(raw) {
|
|
return security.SanitizePrompt(raw, MaxCategoryPromptRunes), false, false
|
|
}
|
|
return strings.TrimSpace(aiprompts.CategoryEnhanceUserTemplate), false, true
|
|
}
|
|
|
|
if preferSeed && seedLegacy != "" {
|
|
p, leg, fb := trySeed(seedLegacy)
|
|
return p, true, leg, fb
|
|
}
|
|
for _, lang := range []string{"sl", company.LangPromptAny} {
|
|
if cur := strings.TrimSpace(current[lang]); aiprompts.IsLegacyCombinedEnhancePrompt(cur) {
|
|
return aiprompts.SplitLegacyCombinedEnhancePrompt(cur), false, true, false
|
|
}
|
|
}
|
|
for _, cur := range current {
|
|
if aiprompts.IsLegacyCombinedEnhancePrompt(cur) {
|
|
return aiprompts.SplitLegacyCombinedEnhancePrompt(cur), false, true, false
|
|
}
|
|
}
|
|
if seedLegacy != "" {
|
|
p, leg, fb := trySeed(seedLegacy)
|
|
return p, true, leg, fb
|
|
}
|
|
return strings.TrimSpace(aiprompts.CategoryEnhanceUserTemplate), false, false, true
|
|
}
|
|
|
|
func repairCompanyCategoryEnhancePrompts(
|
|
ctx context.Context,
|
|
pool *pgxpool.Pool,
|
|
companyID uuid.UUID,
|
|
companyName string,
|
|
seedByNorm map[string]string,
|
|
seedByUID map[string]string,
|
|
dryRun bool,
|
|
forceFromSeed bool,
|
|
out *RepairCategoryEnhancePromptsResult,
|
|
) (int, error) {
|
|
rows, err := pool.Query(ctx, `
|
|
SELECT id,
|
|
COALESCE(unique_id, ''),
|
|
name,
|
|
COALESCE(prompt, '{}'::jsonb),
|
|
title_template,
|
|
description_template
|
|
FROM categories
|
|
WHERE company_id = $1`, companyID)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("list categories for %s: %w", companyName, err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
updatedHere := 0
|
|
for rows.Next() {
|
|
var id uuid.UUID
|
|
var uniqueID, name string
|
|
var raw []byte
|
|
var titleTpl, descTpl []byte
|
|
if err := rows.Scan(&id, &uniqueID, &name, &raw, &titleTpl, &descTpl); err != nil {
|
|
return updatedHere, err
|
|
}
|
|
out.CategoriesSeen++
|
|
|
|
m, err := company.DecodeLangPromptMap(raw)
|
|
if err != nil {
|
|
return updatedHere, fmt.Errorf("decode prompt category=%s company=%s: %w", id, companyName, err)
|
|
}
|
|
|
|
seedLegacy := pickSeedPrompt(uniqueID, name, seedByNorm, seedByUID)
|
|
needPrompt := company.HasAnyPrompt(m) && !categoryEnhancePromptMapOK(m)
|
|
// Empty prompt → write sectioned overlay (seed split when available, else shared template).
|
|
if !company.HasAnyPrompt(m) {
|
|
needPrompt = true
|
|
}
|
|
|
|
var wantPrompt string
|
|
if seedLegacy != "" && (forceFromSeed || needPrompt) {
|
|
wantPrompt, _, _, _ = computeRepairedEnhancePrompt(m, seedLegacy, forceFromSeed)
|
|
wantPrompt = security.SanitizePrompt(wantPrompt, MaxCategoryPromptRunes)
|
|
if cur := currentEnhancePrompt(m); forceFromSeed && cur != "" && cur == wantPrompt && categoryEnhancePromptMapOK(m) {
|
|
needPrompt = false
|
|
wantPrompt = ""
|
|
} else if wantPrompt != "" {
|
|
needPrompt = true
|
|
}
|
|
}
|
|
|
|
titleRules := legacyTitleRules(m, seedLegacy)
|
|
needTitle := aiprompts.TitleTemplateNeedsRepair(titleTpl)
|
|
legacyParts := legacyEnhanceParts(m, seedLegacy)
|
|
needDesc := aiprompts.DescriptionTemplateNeedsRepair(descTpl)
|
|
var wantTitleTpl, wantDescTpl string
|
|
if forceFromSeed && seedLegacy != "" {
|
|
if strings.TrimSpace(titleRules) != "" {
|
|
wantTitleTpl = aiprompts.DeriveTitleTemplateJSON(titleRules)
|
|
if !jsonbEqual(titleTpl, []byte(wantTitleTpl)) {
|
|
needTitle = true
|
|
} else {
|
|
needTitle = false
|
|
wantTitleTpl = ""
|
|
}
|
|
}
|
|
if legacyParts.WasLegacy && (strings.TrimSpace(legacyParts.DescriptionRules) != "" || strings.TrimSpace(legacyParts.MetaRules) != "") {
|
|
wantDescTpl = aiprompts.DeriveDescriptionTemplateJSON(legacyParts)
|
|
if strings.TrimSpace(wantDescTpl) != "" && !jsonbEqual(descTpl, []byte(wantDescTpl)) {
|
|
needDesc = true
|
|
} else if strings.TrimSpace(wantDescTpl) == "" || jsonbEqual(descTpl, []byte(wantDescTpl)) {
|
|
needDesc = false
|
|
wantDescTpl = ""
|
|
}
|
|
}
|
|
}
|
|
if needDesc && strings.TrimSpace(legacyParts.DescriptionRules) == "" && strings.TrimSpace(legacyParts.MetaRules) == "" {
|
|
needDesc = false
|
|
}
|
|
if !needPrompt && !needTitle && !needDesc {
|
|
if company.HasAnyPrompt(m) {
|
|
out.AlreadyOK++
|
|
} else {
|
|
out.EmptySkipped++
|
|
}
|
|
continue
|
|
}
|
|
|
|
if needPrompt && wantPrompt == "" {
|
|
wantPrompt = resolveRepairedEnhancePrompt(m, seedLegacy, forceFromSeed && seedLegacy != "", out)
|
|
wantPrompt = security.SanitizePrompt(wantPrompt, MaxCategoryPromptRunes)
|
|
if wantPrompt == "" {
|
|
return updatedHere, fmt.Errorf("repaired prompt empty category=%s", id)
|
|
}
|
|
} else if needPrompt {
|
|
// Record seed/split stats for the prompt we already computed.
|
|
_, fromSeed, fromLegacy, fallback := computeRepairedEnhancePrompt(m, seedLegacy, forceFromSeed && seedLegacy != "")
|
|
if fromSeed {
|
|
out.SeedMatched++
|
|
}
|
|
if fromLegacy {
|
|
out.SplitFromLegacy++
|
|
}
|
|
if fallback {
|
|
out.FallbackTemplate++
|
|
}
|
|
}
|
|
|
|
out.WouldUpdate++
|
|
if dryRun {
|
|
if needTitle {
|
|
out.TitleTemplateBackfill++
|
|
}
|
|
if needDesc {
|
|
out.DescTemplateBackfill++
|
|
}
|
|
updatedHere++
|
|
continue
|
|
}
|
|
|
|
if needPrompt {
|
|
want := company.LangPromptMap{
|
|
"sl": wantPrompt,
|
|
company.LangPromptAny: wantPrompt,
|
|
}
|
|
cleaned, err := company.SanitizeLangPromptMap(want, MaxCategoryPromptRunes)
|
|
if err != nil {
|
|
return updatedHere, fmt.Errorf("sanitize prompt category=%s: %w", id, err)
|
|
}
|
|
encoded, err := company.EncodeLangPromptMap(cleaned)
|
|
if err != nil {
|
|
return updatedHere, err
|
|
}
|
|
ct, err := pool.Exec(ctx, `
|
|
UPDATE categories
|
|
SET prompt = $3::jsonb, updated_at = now()
|
|
WHERE id = $1 AND company_id = $2`, id, companyID, string(encoded))
|
|
if err != nil {
|
|
return updatedHere, fmt.Errorf("update prompt category=%s: %w", id, err)
|
|
}
|
|
if ct.RowsAffected() == 0 {
|
|
return updatedHere, fmt.Errorf("category %s not updated (company mismatch?)", id)
|
|
}
|
|
}
|
|
|
|
if needTitle {
|
|
tpl := wantTitleTpl
|
|
if tpl == "" {
|
|
tpl = aiprompts.DeriveTitleTemplateJSON(titleRules)
|
|
}
|
|
ct, err := pool.Exec(ctx, `
|
|
UPDATE categories
|
|
SET title_template = $3::jsonb, updated_at = now()
|
|
WHERE id = $1 AND company_id = $2`, id, companyID, tpl)
|
|
if err != nil {
|
|
return updatedHere, fmt.Errorf("backfill title_template category=%s: %w", id, err)
|
|
}
|
|
if ct.RowsAffected() > 0 {
|
|
out.TitleTemplateBackfill++
|
|
}
|
|
}
|
|
|
|
if needDesc {
|
|
tpl := wantDescTpl
|
|
if tpl == "" {
|
|
tpl = aiprompts.DeriveDescriptionTemplateJSON(legacyParts)
|
|
}
|
|
if strings.TrimSpace(tpl) != "" {
|
|
ct, err := pool.Exec(ctx, `
|
|
UPDATE categories
|
|
SET description_template = $3::jsonb, updated_at = now()
|
|
WHERE id = $1 AND company_id = $2`, id, companyID, tpl)
|
|
if err != nil {
|
|
return updatedHere, fmt.Errorf("backfill description_template category=%s: %w", id, err)
|
|
}
|
|
if ct.RowsAffected() > 0 {
|
|
out.DescTemplateBackfill++
|
|
}
|
|
}
|
|
}
|
|
|
|
out.Updated++
|
|
updatedHere++
|
|
}
|
|
return updatedHere, rows.Err()
|
|
}
|
|
|
|
func currentEnhancePrompt(m company.LangPromptMap) string {
|
|
for _, lang := range []string{"sl", company.LangPromptAny} {
|
|
if p := strings.TrimSpace(m[lang]); p != "" {
|
|
return p
|
|
}
|
|
}
|
|
for _, p := range m {
|
|
if t := strings.TrimSpace(p); t != "" {
|
|
return t
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func legacyEnhanceParts(current company.LangPromptMap, seedLegacy string) aiprompts.LegacyEnhanceParts {
|
|
if seedLegacy != "" {
|
|
parts := aiprompts.ParseLegacyCombinedEnhancePrompt(seedLegacy)
|
|
if parts.WasLegacy {
|
|
return parts
|
|
}
|
|
}
|
|
for _, lang := range []string{"sl", company.LangPromptAny} {
|
|
parts := aiprompts.ParseLegacyCombinedEnhancePrompt(current[lang])
|
|
if parts.WasLegacy {
|
|
return parts
|
|
}
|
|
}
|
|
for _, cur := range current {
|
|
parts := aiprompts.ParseLegacyCombinedEnhancePrompt(cur)
|
|
if parts.WasLegacy {
|
|
return parts
|
|
}
|
|
}
|
|
return aiprompts.LegacyEnhanceParts{}
|
|
}
|
|
|
|
func jsonbTemplatePresent(raw []byte) bool {
|
|
s := strings.TrimSpace(string(raw))
|
|
if s == "" || s == "null" || s == "{}" || s == "[]" {
|
|
return false
|
|
}
|
|
var obj map[string]any
|
|
if err := json.Unmarshal(raw, &obj); err != nil {
|
|
return true // non-empty non-object still counts as present
|
|
}
|
|
if elems, ok := obj["elements"].([]any); ok && len(elems) > 0 {
|
|
return true
|
|
}
|
|
if sections, ok := obj["sections"].([]any); ok && len(sections) > 0 {
|
|
return true
|
|
}
|
|
if mt, ok := obj["metaTitle"].(string); ok && strings.TrimSpace(mt) != "" {
|
|
return true
|
|
}
|
|
if md, ok := obj["metaDescription"].(string); ok && strings.TrimSpace(md) != "" {
|
|
return true
|
|
}
|
|
// Any other non-empty keys.
|
|
return len(obj) > 0
|
|
}
|
|
|
|
func jsonbEqual(a, b []byte) bool {
|
|
as := strings.TrimSpace(string(a))
|
|
bs := strings.TrimSpace(string(b))
|
|
if as == "" || as == "null" {
|
|
as = ""
|
|
}
|
|
if bs == "" || bs == "null" {
|
|
bs = ""
|
|
}
|
|
if as == bs {
|
|
return true
|
|
}
|
|
var ao, bo any
|
|
if err := json.Unmarshal([]byte(as), &ao); err != nil {
|
|
return false
|
|
}
|
|
if err := json.Unmarshal([]byte(bs), &bo); err != nil {
|
|
return false
|
|
}
|
|
ab, err1 := json.Marshal(ao)
|
|
bb, err2 := json.Marshal(bo)
|
|
if err1 != nil || err2 != nil {
|
|
return false
|
|
}
|
|
return string(ab) == string(bb)
|
|
}
|
|
|
|
func legacyTitleRules(current company.LangPromptMap, seedLegacy string) string {
|
|
if seedLegacy != "" {
|
|
parts := aiprompts.ParseLegacyCombinedEnhancePrompt(seedLegacy)
|
|
if parts.WasLegacy && strings.TrimSpace(parts.TitleRules) != "" {
|
|
return parts.TitleRules
|
|
}
|
|
}
|
|
for _, lang := range []string{"sl", company.LangPromptAny} {
|
|
parts := aiprompts.ParseLegacyCombinedEnhancePrompt(current[lang])
|
|
if parts.WasLegacy && strings.TrimSpace(parts.TitleRules) != "" {
|
|
return parts.TitleRules
|
|
}
|
|
}
|
|
for _, cur := range current {
|
|
parts := aiprompts.ParseLegacyCombinedEnhancePrompt(cur)
|
|
if parts.WasLegacy && strings.TrimSpace(parts.TitleRules) != "" {
|
|
return parts.TitleRules
|
|
}
|
|
}
|
|
return ""
|
|
}
|