`849bc22`

fixes

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 5 months ago

Status	File	+	-
M	`internal/config/config.go`	2	2
M	`internal/llm/fallback_database.go`	10	1
M	`internal/llm/smart_fallback.go`	20	2

internal/config/config.gomodified

  		},
  		Local: LocalConfig{
  			Enabled:  true,
 -			Provider: "ollama",
 +			Provider: "ollama",
  			Endpoint: "http://127.0.0.1:11434",
  			Model:    "llama3.2:3b",
 -			Timeout:  8,  // Adequate time for local LLM processing
 +			Timeout:  15,  // Adequate time for local LLM processing (increased for slower systems)
  		},
  		General: GeneralConfig{
  			Personality:  "savage",

internal/llm/fallback_database.gomodified

  package llm
 +import "time"
++
  // ExpandedFallbackDatabase contains hundreds of brutal, wry insults organized by command type
  // This database is used when LLM backends are unavailable to provide instant feedback
  var ExpandedFallbackDatabase = map[string][]string{
  		responses = ExpandedFallbackDatabase["generic"]
+ 	}
 -	// Improved pseudo-random selection using command text for variation
 +	// Improved pseudo-random selection using command text + time for variation
 +	// Add time-based entropy to provide variety over time while maintaining
 +	// some determinism within short timeframes (10-second buckets)
 +	timeBucket := time.Now().Unix() / 10 // 10-second buckets
++
  	hash := 0
  	fullText := commandType + command
  	for _, char := range fullText {
  		hash = hash*31 + int(char)
+ 	}
 +	// Mix in time-based entropy
 +	hash = hash*31 + int(timeBucket)
++
  	if hash < 0 {
  		hash = -hash
+ 	}

internal/llm/smart_fallback.gomodified

  	"regexp"
  	"strconv"
  	"strings"
 +	"sync"
  	"time"
+ )
  	return ""
+ }
 -// selectInsult picks an insult using pseudo-random selection
 +// selectInsult picks an insult using pseudo-random selection with time-based entropy
 +// This adds variety over time while maintaining some determinism within short timeframes
  func selectInsult(insults []string, seed string) string {
  	if len(insults) == 0 {
  		return ""
+ 	}
 +	// Add time-based entropy: same command gets different insults over time
 +	// Using 10-second buckets means same command within ~10 seconds gets same insult,
 +	// but after that, the insult changes. This provides both consistency and variety.
 +	timeBucket := time.Now().Unix() / 10 // 10-second buckets
++
  	hash := 0
 +	// Hash the seed (command)
  	for _, char := range seed {
  		hash = hash*31 + int(char)
+ 	}
 +	// Mix in time-based entropy
 +	hash = hash*31 + int(timeBucket)
++
  	if hash < 0 {
  		hash = -hash
+ 	}
+ }
  // failureTracker stores recent command failures (simple in-process tracking)
 -var failureTracker = make(map[string]int)
 +var (
 +	failureTracker      = make(map[string]int)
 +	failureTrackerMutex sync.Mutex
 +)
  // trackFailure tracks command failures and detects repeats
  func trackFailure(command string) bool {
+ 	}
  	cmdHash := strconv.Itoa(hash)
 +	// Thread-safe map access
 +	failureTrackerMutex.Lock()
 +	defer failureTrackerMutex.Unlock()
++
  	// Increment failure count
  	failureTracker[cmdHash]++