BugFix

internal/engine/runtime.go

@@ -11,68 +11,52 @@ import (
 	"github.com/local/glpi-neural-brain/internal/model"
 )
 
-const uncategorizedFilter = graph.UncategorizedFilter
-const unsourcedFilter = graph.UnsourcedFilter
-
 type RuntimeSettings struct {
-	LearningEnabled    bool     `json:"learning_enabled"`
-	ThinkingEnabled    bool     `json:"thinking_enabled"`
-	LearningCategories []string `json:"learning_categories"`
-	DisplayCategories  []string `json:"display_categories"`
-	ThinkingCategories []string `json:"thinking_categories"`
-	LearningSources    []string `json:"learning_sources"`
-	DisplaySources     []string `json:"display_sources"`
-	ThinkingSources    []string `json:"thinking_sources"`
-	ViewMode           string   `json:"view_mode"`
-	MaxDisplayNodes    int      `json:"max_display_nodes"`
-	LowPowerMode       bool     `json:"low_power_mode"`
-}
-
-type RuntimeFilterInfo struct {
-	Categories           []string `json:"categories"`
-	Sources              []string `json:"sources"`
-	CategoriesRestricted bool     `json:"categories_restricted"`
-	SourcesRestricted    bool     `json:"sources_restricted"`
-	MatchesNone          bool     `json:"matches_none"`
+	SourceFilterVersion int      `json:"source_filter_version"`
+	LearningEnabled     bool     `json:"learning_enabled"`
+	ThinkingEnabled     bool     `json:"thinking_enabled"`
+	LearningSources     []string `json:"learning_sources"`
+	DisplaySources      []string `json:"display_sources"`
+	ThinkingSources     []string `json:"thinking_sources"`
+	ViewMode            string   `json:"view_mode"`
+	MaxDisplayNodes     int      `json:"max_display_nodes"`
+	LowPowerMode        bool     `json:"low_power_mode"`
 }
 
 type RuntimeSettingsView struct {
 	RuntimeSettings
-	EffectiveLearning RuntimeFilterInfo `json:"effective_learning"`
-	EffectiveDisplay  RuntimeFilterInfo `json:"effective_display"`
-	EffectiveThinking RuntimeFilterInfo `json:"effective_thinking"`
-	AdminLearning     RuntimeFilterInfo `json:"admin_learning"`
-	AdminDisplay      RuntimeFilterInfo `json:"admin_display"`
-	AdminThinking     RuntimeFilterInfo `json:"admin_thinking"`
+	GLPIKBSource string `json:"glpi_kb_source"`
 }
 
-type CategoryInfo struct {
+type SourceInfo struct {
 	Name  string `json:"name"`
 	Count int    `json:"count"`
 }
 
-type SourceInfo = CategoryInfo
-
 func (e *Engine) defaultRuntimeSettings() RuntimeSettings {
-	// Category/source values in Config are administrative ceilings. The WebUI
-	// starts at "all allowed" (empty selection), not by copying the ceiling into
-	// mutable runtime state.
+	// Environment source lists are startup defaults only. Once a corresponding
+	// field exists in runtime-settings.json, that persisted WebUI value is the
+	// single authoritative selection. There is no ENV/WebUI intersection.
 	return normalizeRuntimeSettings(RuntimeSettings{
-		LearningEnabled: e.Cfg.LearningEnabled,
-		ThinkingEnabled: e.Cfg.ThinkingEnabled,
-		ViewMode:        e.Cfg.DefaultView,
-		MaxDisplayNodes: e.Cfg.MaxDisplayNodes,
-		LowPowerMode:    e.Cfg.LowPowerMode,
+		SourceFilterVersion: 1,
+		LearningEnabled:     e.Cfg.LearningEnabled,
+		ThinkingEnabled:     e.Cfg.ThinkingEnabled,
+		LearningSources:     append([]string(nil), e.Cfg.LearningSources...),
+		DisplaySources:      append([]string(nil), e.Cfg.DisplaySources...),
+		ThinkingSources:     append([]string(nil), e.Cfg.ThinkingSources...),
+		ViewMode:            e.Cfg.DefaultView,
+		MaxDisplayNodes:     e.Cfg.MaxDisplayNodes,
+		LowPowerMode:        e.Cfg.LowPowerMode,
 	})
 }
 
 func normalizeRuntimeSettings(in RuntimeSettings) RuntimeSettings {
-	in.LearningCategories = normalizeValues(in.LearningCategories)
-	in.DisplayCategories = normalizeValues(in.DisplayCategories)
-	in.ThinkingCategories = normalizeValues(in.ThinkingCategories)
-	in.LearningSources = normalizeValues(in.LearningSources)
-	in.DisplaySources = normalizeValues(in.DisplaySources)
-	in.ThinkingSources = normalizeValues(in.ThinkingSources)
+	if in.SourceFilterVersion != 1 {
+		in.SourceFilterVersion = 1
+	}
+	in.LearningSources = normalizeSources(in.LearningSources)
+	in.DisplaySources = normalizeSources(in.DisplaySources)
+	in.ThinkingSources = normalizeSources(in.ThinkingSources)
 	in.ViewMode = strings.ToLower(strings.TrimSpace(in.ViewMode))
 	if in.ViewMode == "" {
 		in.ViewMode = "neural"
@@ -89,31 +73,35 @@ func normalizeRuntimeSettings(in RuntimeSettings) RuntimeSettings {
 	return in
 }
 
-func normalizeValues(values []string) []string {
-	seen := map[string]string{}
+// normalizeSources preserves the exact source spelling used by KB files. Only
+// surrounding whitespace and byte-identical duplicates are removed.
+func normalizeSources(values []string) []string {
+	seen := map[string]struct{}{}
+	out := make([]string, 0, len(values))
 	for _, value := range values {
 		value = strings.TrimSpace(value)
 		if value == "" {
 			continue
 		}
-		key := strings.ToLower(value)
-		if _, exists := seen[key]; !exists {
-			seen[key] = value
+		if _, exists := seen[value]; exists {
+			continue
 		}
-	}
-	out := make([]string, 0, len(seen))
-	for _, value := range seen {
+		seen[value] = struct{}{}
 		out = append(out, value)
 	}
-	sort.Slice(out, func(i, j int) bool { return strings.ToLower(out[i]) < strings.ToLower(out[j]) })
+	sort.Slice(out, func(i, j int) bool {
+		li, lj := strings.ToLower(out[i]), strings.ToLower(out[j])
+		if li == lj {
+			return out[i] < out[j]
+		}
+		return li < lj
+	})
 	return out
 }
 
-func normalizeCategories(values []string) []string { return normalizeValues(values) }
-
-// loadRuntimeSettings merges individual persisted fields. Older files that do
-// not contain newly introduced fields inherit defaults instead of silently
-// zeroing unrelated settings.
+// loadRuntimeSettings merges individual persisted fields. Legacy category fields
+// and unversioned source selections are intentionally ignored so the previous
+// ambiguous filter system cannot silently survive this source-only migration.
 func (e *Engine) loadRuntimeSettings() {
 	settings := e.defaultRuntimeSettings()
 	if strings.TrimSpace(e.runtimePath) != "" {
@@ -139,12 +127,14 @@ func mergeRuntimeSettingsJSON(settings *RuntimeSettings, data []byte) {
 	}
 	decode("learning_enabled", &settings.LearningEnabled)
 	decode("thinking_enabled", &settings.ThinkingEnabled)
-	decode("learning_categories", &settings.LearningCategories)
-	decode("display_categories", &settings.DisplayCategories)
-	decode("thinking_categories", &settings.ThinkingCategories)
-	decode("learning_sources", &settings.LearningSources)
-	decode("display_sources", &settings.DisplaySources)
-	decode("thinking_sources", &settings.ThinkingSources)
+	var version int
+	decode("source_filter_version", &version)
+	if version == 1 {
+		settings.SourceFilterVersion = 1
+		decode("learning_sources", &settings.LearningSources)
+		decode("display_sources", &settings.DisplaySources)
+		decode("thinking_sources", &settings.ThinkingSources)
+	}
 	decode("view_mode", &settings.ViewMode)
 	decode("max_display_nodes", &settings.MaxDisplayNodes)
 	decode("low_power_mode", &settings.LowPowerMode)
@@ -154,9 +144,6 @@ func (e *Engine) RuntimeSettings() RuntimeSettings {
 	e.runtimeMu.RLock()
 	settings := e.runtime
 	e.runtimeMu.RUnlock()
-	settings.LearningCategories = append([]string{}, settings.LearningCategories...)
-	settings.DisplayCategories = append([]string{}, settings.DisplayCategories...)
-	settings.ThinkingCategories = append([]string{}, settings.ThinkingCategories...)
 	settings.LearningSources = append([]string{}, settings.LearningSources...)
 	settings.DisplaySources = append([]string{}, settings.DisplaySources...)
 	settings.ThinkingSources = append([]string{}, settings.ThinkingSources...)
@@ -164,49 +151,7 @@ func (e *Engine) RuntimeSettings() RuntimeSettings {
 }
 
 func (e *Engine) RuntimeSettingsView() RuntimeSettingsView {
-	settings := e.RuntimeSettings()
-	return RuntimeSettingsView{
-		RuntimeSettings:   settings,
-		EffectiveLearning: filterInfo(e.effectiveLearningFilter()),
-		EffectiveDisplay:  filterInfo(e.effectiveDisplayFilter()),
-		EffectiveThinking: filterInfo(e.effectiveThinkingFilter()),
-		AdminLearning:     adminFilterInfo(e.Cfg.LearningCategories, e.Cfg.LearningSources),
-		AdminDisplay:      adminFilterInfo(e.Cfg.DisplayCategories, e.Cfg.DisplaySources),
-		AdminThinking:     adminFilterInfo(e.Cfg.ThinkingCategories, e.Cfg.ThinkingSources),
-	}
-}
-
-func filterInfo(filter graph.NodeFilter) RuntimeFilterInfo {
-	return RuntimeFilterInfo{
-		Categories:           append([]string{}, filter.Categories...),
-		Sources:              append([]string{}, filter.Sources...),
-		CategoriesRestricted: dimensionRestricted(filter.Categories) || filter.MatchNone,
-		SourcesRestricted:    dimensionRestricted(filter.Sources) || filter.MatchNone,
-		MatchesNone:          filter.MatchNone,
-	}
-}
-
-func adminFilterInfo(categories, sources []string) RuntimeFilterInfo {
-	categories = normalizeValues(categories)
-	sources = normalizeValues(sources)
-	return RuntimeFilterInfo{
-		Categories:           categories,
-		Sources:              sources,
-		CategoriesRestricted: dimensionRestricted(categories),
-		SourcesRestricted:    dimensionRestricted(sources),
-	}
-}
-
-func dimensionRestricted(values []string) bool {
-	if len(values) == 0 {
-		return false
-	}
-	for _, value := range values {
-		if strings.TrimSpace(value) == "*" {
-			return false
-		}
-	}
-	return true
+	return RuntimeSettingsView{RuntimeSettings: e.RuntimeSettings(), GLPIKBSource: strings.TrimSpace(e.Cfg.GLPIKBSource)}
 }
 
 func (e *Engine) SetRuntimeSettings(settings RuntimeSettings) (RuntimeSettings, error) {
@@ -240,28 +185,22 @@ func (e *Engine) SetRuntimeSettings(settings RuntimeSettings) (RuntimeSettings,
 		}
 	}
 
-	view := e.RuntimeSettingsView()
 	e.Broker.Publish(model.Activity{
 		Type:     "runtime.settings.updated",
 		Source:   "ui",
 		Phase:    "control",
-		Message:  "Lern-, Anzeige-, Quellen- und Thinking-Einstellungen wurden aktualisiert",
+		Message:  "Laufzeitmodi und exakte KB-Quellenfilter wurden aktualisiert",
 		Strength: .32,
 		Metadata: map[string]any{
-			"learning_enabled":             settings.LearningEnabled,
-			"thinking_enabled":             settings.ThinkingEnabled,
-			"learning_categories":          len(settings.LearningCategories),
-			"display_categories":           len(settings.DisplayCategories),
-			"thinking_categories":          len(settings.ThinkingCategories),
-			"learning_sources":             len(settings.LearningSources),
-			"display_sources":              len(settings.DisplaySources),
-			"thinking_sources":             len(settings.ThinkingSources),
-			"learning_filter_matches_none": view.EffectiveLearning.MatchesNone,
-			"display_filter_matches_none":  view.EffectiveDisplay.MatchesNone,
-			"thinking_filter_matches_none": view.EffectiveThinking.MatchesNone,
-			"view_mode":                    settings.ViewMode,
-			"max_display_nodes":            settings.MaxDisplayNodes,
-			"low_power_mode":               settings.LowPowerMode,
+			"source_filter_version": settings.SourceFilterVersion,
+			"learning_enabled":      settings.LearningEnabled,
+			"thinking_enabled":      settings.ThinkingEnabled,
+			"learning_sources":      len(settings.LearningSources),
+			"display_sources":       len(settings.DisplaySources),
+			"thinking_sources":      len(settings.ThinkingSources),
+			"view_mode":             settings.ViewMode,
+			"max_display_nodes":     settings.MaxDisplayNodes,
+			"low_power_mode":        settings.LowPowerMode,
 		},
 	})
 	return settings, nil
@@ -282,136 +221,53 @@ func (e *Engine) ThinkingEnabled() bool {
 }
 
 func (e *Engine) effectiveLearningFilter() graph.NodeFilter {
-	settings := e.RuntimeSettings()
-	return effectiveNodeFilter(e.Cfg.LearningCategories, settings.LearningCategories, e.Cfg.LearningSources, settings.LearningSources)
+	return graph.NodeFilter{Sources: e.RuntimeSettings().LearningSources}
 }
 
 func (e *Engine) effectiveDisplayFilter() graph.NodeFilter {
-	settings := e.RuntimeSettings()
-	return effectiveNodeFilter(e.Cfg.DisplayCategories, settings.DisplayCategories, e.Cfg.DisplaySources, settings.DisplaySources)
+	return graph.NodeFilter{Sources: e.RuntimeSettings().DisplaySources}
 }
 
 func (e *Engine) effectiveThinkingFilter() graph.NodeFilter {
-	settings := e.RuntimeSettings()
-	return effectiveNodeFilter(e.Cfg.ThinkingCategories, settings.ThinkingCategories, e.Cfg.ThinkingSources, settings.ThinkingSources)
-}
-
-func effectiveNodeFilter(adminCategories, runtimeCategories, adminSources, runtimeSources []string) graph.NodeFilter {
-	categories, categoryNone := intersectFilterValues(adminCategories, runtimeCategories)
-	sources, sourceNone := intersectFilterValues(adminSources, runtimeSources)
-	return graph.NodeFilter{Categories: categories, Sources: sources, MatchNone: categoryNone || sourceNone}
-}
-
-func intersectFilterValues(admin, runtime []string) ([]string, bool) {
-	admin = normalizeValues(admin)
-	runtime = normalizeValues(runtime)
-	adminRestricted := dimensionRestricted(admin)
-	runtimeRestricted := dimensionRestricted(runtime)
-	if !adminRestricted && !runtimeRestricted {
-		return nil, false
-	}
-	if adminRestricted && !runtimeRestricted {
-		return admin, false
-	}
-	if !adminRestricted && runtimeRestricted {
-		return runtime, false
-	}
-	allowed := make(map[string]string, len(admin))
-	for _, value := range admin {
-		allowed[strings.ToLower(strings.TrimSpace(value))] = value
-	}
-	intersection := make([]string, 0)
-	for _, value := range runtime {
-		if canonical, ok := allowed[strings.ToLower(strings.TrimSpace(value))]; ok {
-			intersection = append(intersection, canonical)
-		}
-	}
-	intersection = normalizeValues(intersection)
-	return intersection, len(intersection) == 0
-}
-
-// Compatibility helpers retained for tests and internal callers that only need
-// the category projection. New code should use the scoped filters above.
-func (e *Engine) learningCategories() []string { return e.effectiveLearningFilter().Categories }
-func (e *Engine) thinkingCategories() []string { return e.effectiveThinkingFilter().Categories }
-
-func (e *Engine) Categories() []CategoryInfo {
-	snapshot := e.Graph.Snapshot()
-	counts := map[string]int{}
-	names := map[string]string{}
-	uncategorized := 0
-	for _, node := range snapshot.Nodes {
-		if node.Kind != "knowledge" && node.Kind != "ai-think" && node.Kind != "external" {
-			continue
-		}
-		if len(node.Categories) == 0 {
-			uncategorized++
-			continue
-		}
-		seen := map[string]bool{}
-		for _, category := range node.Categories {
-			category = strings.TrimSpace(category)
-			if category == "" {
-				continue
-			}
-			key := strings.ToLower(category)
-			if seen[key] {
-				continue
-			}
-			seen[key] = true
-			if _, ok := names[key]; !ok {
-				names[key] = category
-			}
-			counts[key]++
-		}
-	}
-	out := make([]CategoryInfo, 0, len(counts)+1)
-	for key, count := range counts {
-		out = append(out, CategoryInfo{Name: names[key], Count: count})
-	}
-	if uncategorized > 0 {
-		out = append(out, CategoryInfo{Name: uncategorizedFilter, Count: uncategorized})
-	}
-	sortFilterInfo(out)
-	return out
+	return graph.NodeFilter{Sources: e.RuntimeSettings().ThinkingSources}
 }
 
+// Sources lists exact source values seen on knowledge-bearing nodes. The GLPI
+// source configured through GLPI_KB_SOURCE is always present, even before the
+// first GLPI sync or while GLPI ingestion is disabled.
 func (e *Engine) Sources() []SourceInfo {
-	snapshot := e.Graph.Snapshot()
+	return sourceInfos(e.Graph.Snapshot(), e.Cfg.GLPIKBSource)
+}
+
+func sourceInfos(snapshot model.Snapshot, configuredGLPI string) []SourceInfo {
 	counts := map[string]int{}
-	names := map[string]string{}
-	unsourced := 0
+	glpiSource := strings.TrimSpace(configuredGLPI)
+	if glpiSource != "" {
+		counts[glpiSource] = 0
+	}
 	for _, node := range snapshot.Nodes {
 		if node.Kind != "knowledge" && node.Kind != "ai-think" && node.Kind != "external" {
 			continue
 		}
 		source := strings.TrimSpace(graph.NodeSource(node))
 		if source == "" {
-			unsourced++
 			continue
 		}
-		key := strings.ToLower(source)
-		if _, ok := names[key]; !ok {
-			names[key] = source
+		counts[source]++
+	}
+	result := make([]SourceInfo, 0, len(counts))
+	for name, count := range counts {
+		result = append(result, SourceInfo{Name: name, Count: count})
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Count == result[j].Count {
+			li, lj := strings.ToLower(result[i].Name), strings.ToLower(result[j].Name)
+			if li == lj {
+				return result[i].Name < result[j].Name
+			}
+			return li < lj
 		}
-		counts[key]++
-	}
-	result := make([]SourceInfo, 0, len(counts)+1)
-	for key, count := range counts {
-		result = append(result, SourceInfo{Name: names[key], Count: count})
-	}
-	if unsourced > 0 {
-		result = append(result, SourceInfo{Name: unsourcedFilter, Count: unsourced})
-	}
-	sortFilterInfo(result)
+		return result[i].Count > result[j].Count
+	})
 	return result
 }
-
-func sortFilterInfo(out []CategoryInfo) {
-	sort.Slice(out, func(i, j int) bool {
-		if out[i].Count == out[j].Count {
-			return strings.ToLower(out[i].Name) < strings.ToLower(out[j].Name)
-		}
-		return out[i].Count > out[j].Count
-	})
-}