Alfred
/
qc-text-builder
1
0
Fork 0
Código Issues 0 Pull requests 0 Versões 0 Wiki Atividade
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
17 Commits
1 Branch
35MB
Tag: 4f7d80c06b
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de 4f7d80c06b
${ noResults }
qc-text-builder/internal/mapping/suggestions.go

638 linhas
20KB
Original Anotar Histórico 

  1. package mapping

  2. 

  3. import (

  4. 	"context"

  5. 	"fmt"

  6. 	"sort"

  7. 	"strings"

  8. 	"time"

  9. 

  10. 	"qctextbuilder/internal/domain"

  11. )

  12. 

  13. type SuggestionRequest struct {

  14. 	TemplateID    int64

  15. 	DraftID       string

  16. 	Fields        []domain.TemplateField

  17. 	GlobalData    map[string]any

  18. 	DraftContext  *domain.DraftContext

  19. 	MasterPrompt  string

  20. 	PromptBlocks  []domain.PromptBlockConfig

  21. 	Existing      map[string]string

  22. 	IncludeFilled bool

  23. }

  24. 

  25. type Suggestion struct {

  26. 	FieldPath string `json:"fieldPath"`

  27. 	Slot      string `json:"slot,omitempty"`

  28. 	Value     string `json:"value"`

  29. 	Reason    string `json:"reason,omitempty"`

  30. 	Source    string `json:"source,omitempty"`

  31. }

  32. 

  33. type SuggestionResult struct {

  34. 	Suggestions []Suggestion          `json:"suggestions"`

  35. 	ByFieldPath map[string]Suggestion `json:"byFieldPath"`

  36. }

  37. 

  38. func SuggestFieldValues(req SuggestionRequest) SuggestionResult {

  39. 	return SuggestFieldValuesRuleBased(req)

  40. }

  41. 

  42. func SuggestFieldValuesRuleBased(req SuggestionRequest) SuggestionResult {

  43. 	existing := req.Existing

  44. 	if existing == nil {

  45. 		existing = map[string]string{}

  46. 	}

  47. 	mappingResult := MapTemplateFieldsToSemanticSlots(req.Fields)

  48. 	ctx := suggestionContextFrom(req.GlobalData, req.DraftContext)

  49. 

  50. 	out := SuggestionResult{

  51. 		Suggestions: make([]Suggestion, 0),

  52. 		ByFieldPath: map[string]Suggestion{},

  53. 	}

  54. 	seen := map[string]struct{}{}

  55. 

  56. 	targets := append([]SemanticSlotTarget(nil), mappingResult.Targets...)

  57. 	sort.SliceStable(targets, func(i, j int) bool {

  58. 		if targets[i].FieldPath == targets[j].FieldPath {

  59. 			return targets[i].Slot < targets[j].Slot

  60. 		}

  61. 		return targets[i].FieldPath < targets[j].FieldPath

  62. 	})

  63. 

  64. 	for _, target := range targets {

  65. 		if _, ok := seen[target.FieldPath]; ok {

  66. 			continue

  67. 		}

  68. 		if !req.IncludeFilled && strings.TrimSpace(existing[target.FieldPath]) != "" {

  69. 			continue

  70. 		}

  71. 		value, reason, ok := suggestValueForSlot(target.Slot, ctx)

  72. 		if !ok || strings.TrimSpace(value) == "" {

  73. 			continue

  74. 		}

  75. 		suggestion := Suggestion{

  76. 			FieldPath: target.FieldPath,

  77. 			Slot:      target.Slot,

  78. 			Value:     value,

  79. 			Reason:    reason,

  80. 			Source:    domain.DraftSuggestionSourceFallbackRuleBased,

  81. 		}

  82. 		out.Suggestions = append(out.Suggestions, suggestion)

  83. 		out.ByFieldPath[target.FieldPath] = suggestion

  84. 		seen[target.FieldPath] = struct{}{}

  85. 	}

  86. 

  87. 	return out

  88. }

  89. 

  90. type suggestionContext struct {

  91. 	CompanyName      string

  92. 	BusinessType     string

  93. 	WebsiteSummary   string

  94. 	LocaleStyle      string

  95. 	MarketStyle      string

  96. 	AddressMode      string

  97. 	ContentTone      string

  98. 	PromptNote       string

  99. 	DescriptionShort string

  100. 	DescriptionLong  string

  101. 	Mission          string

  102. }

  103. 

  104. func suggestionContextFrom(globalData map[string]any, draftContext *domain.DraftContext) suggestionContext {

  105. 	ctx := suggestionContext{

  106. 		CompanyName:      getMapString(globalData, "companyName"),

  107. 		BusinessType:     getMapString(globalData, "businessType"),

  108. 		DescriptionShort: getMapString(globalData, "descriptionShort"),

  109. 		DescriptionLong:  getMapString(globalData, "descriptionLong"),

  110. 		Mission:          getMapString(globalData, "mission"),

  111. 	}

  112. 	if draftContext == nil {

  113. 		return ctx

  114. 	}

  115. 	if strings.TrimSpace(ctx.BusinessType) == "" {

  116. 		ctx.BusinessType = strings.TrimSpace(draftContext.LLM.BusinessType)

  117. 	}

  118. 	ctx.WebsiteSummary = strings.TrimSpace(draftContext.LLM.WebsiteSummary)

  119. 	ctx.LocaleStyle = strings.TrimSpace(draftContext.LLM.StyleProfile.LocaleStyle)

  120. 	ctx.MarketStyle = strings.TrimSpace(draftContext.LLM.StyleProfile.MarketStyle)

  121. 	ctx.AddressMode = strings.TrimSpace(draftContext.LLM.StyleProfile.AddressMode)

  122. 	ctx.ContentTone = strings.TrimSpace(draftContext.LLM.StyleProfile.ContentTone)

  123. 	ctx.PromptNote = strings.TrimSpace(draftContext.LLM.StyleProfile.PromptInstructions)

  124. 	return ctx

  125. }

  126. 

  127. func suggestValueForSlot(slot string, ctx suggestionContext) (string, string, bool) {

  128. 	company := fallback(ctx.CompanyName, "Ihr Unternehmen")

  129. 	business := fallback(ctx.BusinessType, "Angebot")

  130. 	toneAdj := toneAdjective(ctx.ContentTone)

  131. 	audienceLine := audienceFlavor(ctx)

  132. 

  133. 	switch {

  134. 	case slot == "hero.title":

  135. 		return strings.TrimSpace(fmt.Sprintf("%s fuer %s mit %s Klarheit", company, business, toneAdj)), "slot-based hero headline", true

  136. 	case slot == "intro.title":

  137. 		return strings.TrimSpace(fmt.Sprintf("Was %s fuer Sie einfacher macht", company)), "slot-based intro title", true

  138. 	case slot == "intro.description":

  139. 		return firstNonEmpty(

  140. 			shortenSentence(ctx.WebsiteSummary, 180),

  141. 			fmt.Sprintf("%s unterstuetzt Kunden mit %s Leistungen, klarer Kommunikation und einem %s Auftritt.", company, business, toneAdj),

  142. 		), "slot-based intro description", true

  143. 	case slot == "about.description":

  144. 		return firstNonEmpty(

  145. 			shortenSentence(ctx.DescriptionLong, 260),

  146. 			shortenSentence(ctx.Mission, 220),

  147. 			fmt.Sprintf("%s steht fuer %s, verlaessliche Zusammenarbeit und einen %s Anspruch in Beratung und Umsetzung.", company, business, toneAdj),

  148. 		), "slot-based about description", true

  149. 	case strings.HasPrefix(slot, "service_items[") && strings.HasSuffix(slot, "].title"):

  150. 		idx := repeatedSlotIndex(slot)

  151. 		return fmt.Sprintf("%s Leistung %d", titleCaseBusiness(business), idx+1), "slot-based service title", true

  152. 	case strings.HasPrefix(slot, "service_items[") && strings.HasSuffix(slot, "].description"):

  153. 		idx := repeatedSlotIndex(slot)

  154. 		return fmt.Sprintf("Praezise Umsetzung von %s mit Fokus auf Nutzen, Verstaendlichkeit und %s Wirkung%s.", business, toneAdj, audienceLineForIndex(audienceLine, idx)), "slot-based service description", true

  155. 	case strings.HasPrefix(slot, "team_items[") && strings.HasSuffix(slot, "].name"):

  156. 		idx := repeatedSlotIndex(slot)

  157. 		return fmt.Sprintf("Ansprechperson %d", idx+1), "slot-based team placeholder", true

  158. 	case strings.HasPrefix(slot, "team_items[") && strings.HasSuffix(slot, "].description"):

  159. 		idx := repeatedSlotIndex(slot)

  160. 		return fmt.Sprintf("Begleitet Projekte bei %s mit fachlicher Sicherheit, klarer Kommunikation und %s Auftreten.", business, toneAdjForIndex(toneAdj, idx)), "slot-based team description", true

  161. 	case strings.HasPrefix(slot, "testimonial_items[") && strings.HasSuffix(slot, "].name"):

  162. 		idx := repeatedSlotIndex(slot)

  163. 		return fmt.Sprintf("Kundin/Kunde %d", idx+1), "slot-based testimonial placeholder", true

  164. 	case strings.HasPrefix(slot, "testimonial_items[") && strings.HasSuffix(slot, "].title"):

  165. 		return firstNonEmpty(

  166. 			testimonialLead(ctx),

  167. 			"Vertrauen durch saubere Zusammenarbeit",

  168. 		), "slot-based testimonial title", true

  169. 	case strings.HasPrefix(slot, "testimonial_items[") && strings.HasSuffix(slot, "].description"):

  170. 		return fmt.Sprintf("%s ueberzeugt mit %s Prozessen, klaren Ergebnissen und einer Zusammenarbeit, die angenehm effizient bleibt.", company, toneAdj), "slot-based testimonial description", true

  171. 	case slot == "cta.text":

  172. 		if ctx.AddressMode == "du" {

  173. 			return "Jetzt unverbindlich anfragen", "slot-based cta", true

  174. 		}

  175. 		return "Jetzt unverbindlich anfragen", "slot-based cta", true

  176. 	default:

  177. 		return "", "", false

  178. 	}

  179. }

  180. 

  181. func getMapString(values map[string]any, key string) string {

  182. 	if values == nil {

  183. 		return ""

  184. 	}

  185. 	raw, _ := values[key].(string)

  186. 	return strings.TrimSpace(raw)

  187. }

  188. 

  189. func fallback(value, alt string) string {

  190. 	if strings.TrimSpace(value) == "" {

  191. 		return alt

  192. 	}

  193. 	return strings.TrimSpace(value)

  194. }

  195. 

  196. func firstNonEmpty(values ...string) string {

  197. 	for _, value := range values {

  198. 		if strings.TrimSpace(value) != "" {

  199. 			return strings.TrimSpace(value)

  200. 		}

  201. 	}

  202. 	return ""

  203. }

  204. 

  205. func shortenSentence(value string, max int) string {

  206. 	trimmed := strings.TrimSpace(value)

  207. 	if trimmed == "" || max <= 0 {

  208. 		return ""

  209. 	}

  210. 	if len([]rune(trimmed)) <= max {

  211. 		return trimmed

  212. 	}

  213. 	runes := []rune(trimmed)

  214. 	return strings.TrimSpace(string(runes[:max])) + "..."

  215. }

  216. 

  217. func repeatedSlotIndex(slot string) int {

  218. 	start := strings.Index(slot, "[")

  219. 	end := strings.Index(slot, "]")

  220. 	if start < 0 || end <= start+1 {

  221. 		return 0

  222. 	}

  223. 	value := strings.TrimSpace(slot[start+1 : end])

  224. 	var idx int

  225. 	_, _ = fmt.Sscanf(value, "%d", &idx)

  226. 	if idx < 0 {

  227. 		return 0

  228. 	}

  229. 	return idx

  230. }

  231. 

  232. func toneAdjective(tone string) string {

  233. 	switch strings.ToLower(strings.TrimSpace(tone)) {

  234. 	case "locker":

  235. 		return "lockerer"

  236. 	case "modern":

  237. 		return "moderner"

  238. 	case "premium":

  239. 		return "hochwertiger"

  240. 	case "freundlich":

  241. 		return "freundlicher"

  242. 	case "professionell":

  243. 		return "professioneller"

  244. 	default:

  245. 		return "klarer"

  246. 	}

  247. }

  248. 

  249. func toneAdjForIndex(adj string, idx int) string {

  250. 	if idx%2 == 0 {

  251. 		return adj

  252. 	}

  253. 	return adj

  254. }

  255. 

  256. func audienceFlavor(ctx suggestionContext) string {

  257. 	parts := make([]string, 0, 2)

  258. 	if strings.TrimSpace(ctx.LocaleStyle) != "" {

  259. 		parts = append(parts, ctx.LocaleStyle)

  260. 	}

  261. 	if strings.TrimSpace(ctx.MarketStyle) != "" {

  262. 		parts = append(parts, ctx.MarketStyle)

  263. 	}

  264. 	return strings.Join(parts, " / ")

  265. }

  266. 

  267. func audienceLineForIndex(value string, idx int) string {

  268. 	if strings.TrimSpace(value) == "" || idx != 0 {

  269. 		return ""

  270. 	}

  271. 	return " fuer " + value

  272. }

  273. 

  274. func titleCaseBusiness(value string) string {

  275. 	trimmed := strings.TrimSpace(value)

  276. 	if trimmed == "" {

  277. 		return "Service"

  278. 	}

  279. 	return strings.ToUpper(string([]rune(trimmed)[0])) + string([]rune(trimmed)[1:])

  280. }

  281. 

  282. func testimonialLead(ctx suggestionContext) string {

  283. 	if strings.TrimSpace(ctx.WebsiteSummary) == "" {

  284. 		return ""

  285. 	}

  286. 	return shortenSentence(ctx.WebsiteSummary, 80)

  287. }

  288. 

  289. func GenerateAllSuggestions(ctx context.Context, generator SuggestionGenerator, req SuggestionRequest, current domain.DraftSuggestionState, now time.Time) domain.DraftSuggestionState {

  290. 	next := cloneSuggestionState(current)

  291. 	if next.ByFieldPath == nil {

  292. 		next.ByFieldPath = map[string]domain.DraftSuggestion{}

  293. 	}

  294. 	generated, err := suggestionResultWithFallback(ctx, generator, SuggestionRequest{

  295. 		TemplateID:    req.TemplateID,

  296. 		DraftID:       req.DraftID,

  297. 		Fields:        req.Fields,

  298. 		GlobalData:    req.GlobalData,

  299. 		DraftContext:  req.DraftContext,

  300. 		MasterPrompt:  req.MasterPrompt,

  301. 		PromptBlocks:  req.PromptBlocks,

  302. 		Existing:      req.Existing,

  303. 		IncludeFilled: true,

  304. 	})

  305. 	if err != nil {

  306. 		return next

  307. 	}

  308. 	mappingLogger().InfoContext(ctx, "autofill state transition",

  309. 		"component", "autofill",

  310. 		"step", "post_generate_result",

  311. 		"action", "generate_all",

  312. 		"generated_count", len(generated.ByFieldPath),

  313. 		"generated_sources", summarizeResultSources(generated),

  314. 		"sample_sources", sampleResultSources(generated, 5),

  315. 	)

  316. 	for _, s := range generated.Suggestions {

  317. 		sliceSource := strings.TrimSpace(s.Source)

  318. 		canonicalSource := ""

  319. 		if canonical, ok := generated.ByFieldPath[strings.TrimSpace(s.FieldPath)]; ok {

  320. 			canonicalSource = strings.TrimSpace(canonical.Source)

  321. 			s = canonical

  322. 		}

  323. 		if existing, exists := next.ByFieldPath[s.FieldPath]; exists {

  324. 			if !shouldReplaceExistingSuggestion(existing, s) {

  325. 				continue

  326. 			}

  327. 		}

  328. 		stored := toDraftSuggestion(s, now)

  329. 		if explicitSource := strings.TrimSpace(s.Source); explicitSource != "" {

  330. 			stored.Source = explicitSource

  331. 		}

  332. 		mappingLogger().InfoContext(ctx, "autofill state transition",

  333. 			"component", "autofill",

  334. 			"step", "apply_field_transition",

  335. 			"action", "generate_all",

  336. 			"field_path", strings.TrimSpace(s.FieldPath),

  337. 			"slice_source", firstNonEmpty(sliceSource, "unknown"),

  338. 			"canonical_source", firstNonEmpty(canonicalSource, "unknown"),

  339. 			"stored_source", firstNonEmpty(strings.TrimSpace(stored.Source), "unknown"),

  340. 		)

  341. 		next.ByFieldPath[s.FieldPath] = stored

  342. 	}

  343. 	mappingLogger().InfoContext(ctx, "autofill state transition",

  344. 		"component", "autofill",

  345. 		"step", "post_generate_apply_state",

  346. 		"action", "generate_all",

  347. 		"state_count", len(next.ByFieldPath),

  348. 		"state_sources", summarizeDraftSuggestionSources(next),

  349. 		"sample_sources", sampleDraftSuggestionSources(next, 5),

  350. 	)

  351. 	next.UpdatedAt = now.UTC()

  352. 	return next

  353. }

  354. 

  355. func RegenerateAllSuggestions(ctx context.Context, generator SuggestionGenerator, req SuggestionRequest, current domain.DraftSuggestionState, now time.Time) domain.DraftSuggestionState {

  356. 	next := cloneSuggestionState(current)

  357. 	next.ByFieldPath = map[string]domain.DraftSuggestion{}

  358. 	generated, err := suggestionResultWithFallback(ctx, generator, SuggestionRequest{

  359. 		TemplateID:    req.TemplateID,

  360. 		DraftID:       req.DraftID,

  361. 		Fields:        req.Fields,

  362. 		GlobalData:    req.GlobalData,

  363. 		DraftContext:  req.DraftContext,

  364. 		MasterPrompt:  req.MasterPrompt,

  365. 		PromptBlocks:  req.PromptBlocks,

  366. 		Existing:      req.Existing,

  367. 		IncludeFilled: true,

  368. 	})

  369. 	if err != nil {

  370. 		return next

  371. 	}

  372. 	mappingLogger().InfoContext(ctx, "autofill state transition",

  373. 		"component", "autofill",

  374. 		"step", "post_generate_result",

  375. 		"action", "regenerate_all",

  376. 		"generated_count", len(generated.ByFieldPath),

  377. 		"generated_sources", summarizeResultSources(generated),

  378. 		"sample_sources", sampleResultSources(generated, 5),

  379. 	)

  380. 	for _, s := range generated.Suggestions {

  381. 		sliceSource := strings.TrimSpace(s.Source)

  382. 		canonicalSource := ""

  383. 		if canonical, ok := generated.ByFieldPath[strings.TrimSpace(s.FieldPath)]; ok {

  384. 			canonicalSource = strings.TrimSpace(canonical.Source)

  385. 			s = canonical

  386. 		}

  387. 		stored := toDraftSuggestion(s, now)

  388. 		if explicitSource := strings.TrimSpace(s.Source); explicitSource != "" {

  389. 			stored.Source = explicitSource

  390. 		}

  391. 		mappingLogger().InfoContext(ctx, "autofill state transition",

  392. 			"component", "autofill",

  393. 			"step", "apply_field_transition",

  394. 			"action", "regenerate_all",

  395. 			"field_path", strings.TrimSpace(s.FieldPath),

  396. 			"slice_source", firstNonEmpty(sliceSource, "unknown"),

  397. 			"canonical_source", firstNonEmpty(canonicalSource, "unknown"),

  398. 			"stored_source", firstNonEmpty(strings.TrimSpace(stored.Source), "unknown"),

  399. 		)

  400. 		next.ByFieldPath[s.FieldPath] = stored

  401. 	}

  402. 	mappingLogger().InfoContext(ctx, "autofill state transition",

  403. 		"component", "autofill",

  404. 		"step", "post_generate_apply_state",

  405. 		"action", "regenerate_all",

  406. 		"state_count", len(next.ByFieldPath),

  407. 		"state_sources", summarizeDraftSuggestionSources(next),

  408. 		"sample_sources", sampleDraftSuggestionSources(next, 5),

  409. 	)

  410. 	next.UpdatedAt = now.UTC()

  411. 	return next

  412. }

  413. 

  414. func RegenerateFieldSuggestion(ctx context.Context, generator SuggestionGenerator, req SuggestionRequest, current domain.DraftSuggestionState, fieldPath string, now time.Time) domain.DraftSuggestionState {

  415. 	target := strings.TrimSpace(fieldPath)

  416. 	if target == "" {

  417. 		return cloneSuggestionState(current)

  418. 	}

  419. 	next := cloneSuggestionState(current)

  420. 	if next.ByFieldPath == nil {

  421. 		next.ByFieldPath = map[string]domain.DraftSuggestion{}

  422. 	}

  423. 	generated, err := suggestionResultWithFallback(ctx, generator, SuggestionRequest{

  424. 		TemplateID:    req.TemplateID,

  425. 		DraftID:       req.DraftID,

  426. 		Fields:        req.Fields,

  427. 		GlobalData:    req.GlobalData,

  428. 		DraftContext:  req.DraftContext,

  429. 		MasterPrompt:  req.MasterPrompt,

  430. 		PromptBlocks:  req.PromptBlocks,

  431. 		Existing:      req.Existing,

  432. 		IncludeFilled: true,

  433. 	})

  434. 	if err != nil {

  435. 		return next

  436. 	}

  437. 	if suggestion, ok := generated.ByFieldPath[target]; ok {

  438. 		next.ByFieldPath[target] = toDraftSuggestion(suggestion, now)

  439. 		next.UpdatedAt = now.UTC()

  440. 	}

  441. 	return next

  442. }

  443. 

  444. func ApplySuggestionsToEmptyFields(fieldValues map[string]string, state domain.DraftSuggestionState, now time.Time) (map[string]string, domain.DraftSuggestionState) {

  445. 	values := cloneFieldValues(fieldValues)

  446. 	next := cloneSuggestionState(state)

  447. 	if next.ByFieldPath == nil {

  448. 		next.ByFieldPath = map[string]domain.DraftSuggestion{}

  449. 	}

  450. 	for path, suggestion := range next.ByFieldPath {

  451. 		if strings.TrimSpace(values[path]) != "" {

  452. 			continue

  453. 		}

  454. 		if strings.TrimSpace(suggestion.Value) == "" {

  455. 			continue

  456. 		}

  457. 		values[path] = strings.TrimSpace(suggestion.Value)

  458. 		suggestion.Status = domain.DraftSuggestionStatusApplied

  459. 		suggestion.UpdatedAt = now.UTC()

  460. 		next.ByFieldPath[path] = suggestion

  461. 	}

  462. 	next.UpdatedAt = now.UTC()

  463. 	return values, next

  464. }

  465. 

  466. func ApplyAllSuggestions(fieldValues map[string]string, state domain.DraftSuggestionState, now time.Time) (map[string]string, domain.DraftSuggestionState) {

  467. 	values := cloneFieldValues(fieldValues)

  468. 	next := cloneSuggestionState(state)

  469. 	if next.ByFieldPath == nil {

  470. 		next.ByFieldPath = map[string]domain.DraftSuggestion{}

  471. 	}

  472. 	for path, suggestion := range next.ByFieldPath {

  473. 		if strings.TrimSpace(suggestion.Value) == "" {

  474. 			continue

  475. 		}

  476. 		values[path] = strings.TrimSpace(suggestion.Value)

  477. 		suggestion.Status = domain.DraftSuggestionStatusApplied

  478. 		suggestion.UpdatedAt = now.UTC()

  479. 		next.ByFieldPath[path] = suggestion

  480. 	}

  481. 	next.UpdatedAt = now.UTC()

  482. 	return values, next

  483. }

  484. 

  485. func ApplySuggestionToField(fieldValues map[string]string, state domain.DraftSuggestionState, fieldPath string, now time.Time) (map[string]string, domain.DraftSuggestionState) {

  486. 	target := strings.TrimSpace(fieldPath)

  487. 	values := cloneFieldValues(fieldValues)

  488. 	next := cloneSuggestionState(state)

  489. 	if target == "" || next.ByFieldPath == nil {

  490. 		return values, next

  491. 	}

  492. 	suggestion, ok := next.ByFieldPath[target]

  493. 	if !ok || strings.TrimSpace(suggestion.Value) == "" {

  494. 		return values, next

  495. 	}

  496. 	values[target] = strings.TrimSpace(suggestion.Value)

  497. 	suggestion.Status = domain.DraftSuggestionStatusApplied

  498. 	suggestion.UpdatedAt = now.UTC()

  499. 	next.ByFieldPath[target] = suggestion

  500. 	next.UpdatedAt = now.UTC()

  501. 	return values, next

  502. }

  503. 

  504. func cloneFieldValues(values map[string]string) map[string]string {

  505. 	if values == nil {

  506. 		return map[string]string{}

  507. 	}

  508. 	out := make(map[string]string, len(values))

  509. 	for k, v := range values {

  510. 		out[k] = v

  511. 	}

  512. 	return out

  513. }

  514. 

  515. func cloneSuggestionState(state domain.DraftSuggestionState) domain.DraftSuggestionState {

  516. 	out := domain.DraftSuggestionState{

  517. 		ByFieldPath: map[string]domain.DraftSuggestion{},

  518. 		UpdatedAt:   state.UpdatedAt,

  519. 	}

  520. 	for path, suggestion := range state.ByFieldPath {

  521. 		out.ByFieldPath[path] = suggestion

  522. 	}

  523. 	return out

  524. }

  525. 

  526. func toDraftSuggestion(s Suggestion, now time.Time) domain.DraftSuggestion {

  527. 	ts := now.UTC()

  528. 	source := strings.TrimSpace(s.Source)

  529. 	if source == "" {

  530. 		source = "unknown"

  531. 	}

  532. 	return domain.DraftSuggestion{

  533. 		FieldPath:   strings.TrimSpace(s.FieldPath),

  534. 		Slot:        strings.TrimSpace(s.Slot),

  535. 		Value:       strings.TrimSpace(s.Value),

  536. 		Reason:      strings.TrimSpace(s.Reason),

  537. 		Source:      source,

  538. 		Status:      domain.DraftSuggestionStatusSuggested,

  539. 		GeneratedAt: ts,

  540. 		UpdatedAt:   ts,

  541. 	}

  542. }

  543. 

  544. func shouldReplaceExistingSuggestion(existing domain.DraftSuggestion, generated Suggestion) bool {

  545. 	existingSource := strings.TrimSpace(existing.Source)

  546. 	generatedSource := strings.TrimSpace(generated.Source)

  547. 	if generatedSource == "" {

  548. 		return false

  549. 	}

  550. 	if generatedSource == domain.DraftSuggestionSourceFallbackRuleBased {

  551. 		return false

  552. 	}

  553. 	return existingSource == domain.DraftSuggestionSourceFallbackRuleBased

  554. }

  555. 

  556. func suggestionResultWithFallback(ctx context.Context, generator SuggestionGenerator, req SuggestionRequest) (SuggestionResult, error) {

  557. 	if generator == nil {

  558. 		return NewRuleBasedSuggestionGenerator().Generate(ctx, req)

  559. 	}

  560. 	return generator.Generate(ctx, req)

  561. }

  562. 

  563. func summarizeResultSources(result SuggestionResult) map[string]int {

  564. 	if len(result.ByFieldPath) == 0 {

  565. 		return map[string]int{}

  566. 	}

  567. 	out := map[string]int{}

  568. 	for _, suggestion := range result.ByFieldPath {

  569. 		source := strings.TrimSpace(suggestion.Source)

  570. 		if source == "" {

  571. 			source = "unknown"

  572. 		}

  573. 		out[source]++

  574. 	}

  575. 	return out

  576. }

  577. 

  578. func summarizeDraftSuggestionSources(state domain.DraftSuggestionState) map[string]int {

  579. 	if len(state.ByFieldPath) == 0 {

  580. 		return map[string]int{}

  581. 	}

  582. 	out := map[string]int{}

  583. 	for _, suggestion := range state.ByFieldPath {

  584. 		source := strings.TrimSpace(suggestion.Source)

  585. 		if source == "" {

  586. 			source = "unknown"

  587. 		}

  588. 		out[source]++

  589. 	}

  590. 	return out

  591. }

  592. 

  593. func sampleResultSources(result SuggestionResult, limit int) map[string]string {

  594. 	if limit <= 0 || len(result.ByFieldPath) == 0 {

  595. 		return map[string]string{}

  596. 	}

  597. 	paths := make([]string, 0, len(result.ByFieldPath))

  598. 	for path := range result.ByFieldPath {

  599. 		paths = append(paths, path)

  600. 	}

  601. 	sort.Strings(paths)

  602. 	if len(paths) > limit {

  603. 		paths = paths[:limit]

  604. 	}

  605. 	out := make(map[string]string, len(paths))

  606. 	for _, path := range paths {

  607. 		source := strings.TrimSpace(result.ByFieldPath[path].Source)

  608. 		if source == "" {

  609. 			source = "unknown"

  610. 		}

  611. 		out[path] = source

  612. 	}

  613. 	return out

  614. }

  615. 

  616. func sampleDraftSuggestionSources(state domain.DraftSuggestionState, limit int) map[string]string {

  617. 	if limit <= 0 || len(state.ByFieldPath) == 0 {

  618. 		return map[string]string{}

  619. 	}

  620. 	paths := make([]string, 0, len(state.ByFieldPath))

  621. 	for path := range state.ByFieldPath {

  622. 		paths = append(paths, path)

  623. 	}

  624. 	sort.Strings(paths)

  625. 	if len(paths) > limit {

  626. 		paths = paths[:limit]

  627. 	}

  628. 	out := make(map[string]string, len(paths))

  629. 	for _, path := range paths {

  630. 		source := strings.TrimSpace(state.ByFieldPath[path].Source)

  631. 		if source == "" {

  632. 			source = "unknown"

  633. 		}

  634. 		out[path] = source

  635. 	}

  636. 	return out

  637. }