memory

var DefaultPruningAlgorithm PruningAlgorithm = func(
	memories []*memory.AgentMemory,
	now time.Time,
) []types.AgentMemoryID {
	// Algorithm parameters (const within function)
	const (
		criticalThreshold = -8.0 // Critical score threshold for immediate deletion
		harmfulThreshold  = -5.0 // Harmful score threshold
		harmfulMaxDays    = 90   // Max days unused for harmful memories
		moderateThreshold = -3.0 // Moderate score threshold
		moderateMaxDays   = 180  // Max days unused for moderate memories
	)

	var toDelete []types.AgentMemoryID

	for _, mem := range memories {
		shouldDelete := false

		if mem.Score <= criticalThreshold {
			shouldDelete = true
		}

		if !shouldDelete && mem.Score <= harmfulThreshold {
			daysSinceUsed := calculateDaysSinceUsed(mem, now)
			if daysSinceUsed >= harmfulMaxDays {
				shouldDelete = true
			}
		}

		if !shouldDelete && mem.Score <= moderateThreshold {
			daysSinceUsed := calculateDaysSinceUsed(mem, now)
			if daysSinceUsed >= moderateMaxDays {
				shouldDelete = true
			}
		}

		if shouldDelete {
			toDelete = append(toDelete, mem.ID)
		}
	}

	return toDelete
}

var DefaultScoringAlgorithm ScoringAlgorithm = func(
	memories map[types.AgentMemoryID]*memory.AgentMemory,
	reflection *memory.Reflection,
) map[types.AgentMemoryID]float64 {
	// Algorithm parameters (const within function)
	const (
		helpfulScoreDelta = 2.0   // positive feedback for helpful memories
		harmfulScoreDelta = -3.0  // negative feedback for harmful memories
		emaAlpha          = 0.3   // EMA smoothing factor (weight for new feedback)
		scoreMin          = -10.0 // minimum score value
		scoreMax          = 10.0  // maximum score value
	)

	updates := make(map[types.AgentMemoryID]float64)

	for _, memID := range reflection.HelpfulMemories {
		if mem, exists := memories[memID]; exists {
			delta := helpfulScoreDelta
			newScore := emaAlpha*delta + (1-emaAlpha)*mem.Score
			newScore = clamp(newScore, scoreMin, scoreMax)
			updates[memID] = newScore
		}
	}

	for _, memID := range reflection.HarmfulMemories {
		if mem, exists := memories[memID]; exists {
			delta := harmfulScoreDelta
			newScore := emaAlpha*delta + (1-emaAlpha)*mem.Score
			newScore = clamp(newScore, scoreMin, scoreMax)
			updates[memID] = newScore
		}
	}

	return updates
}

var DefaultSelectionAlgorithm SelectionAlgorithm = func(
	candidates []*memory.AgentMemory,
	queryEmbedding []float32,
	limit int,
) []*memory.AgentMemory {
	// Algorithm parameters (const within function)
	const (
		minQualityScore     = -5.0 // Minimum quality score threshold
		similarityWeight    = 0.5  // Weight for similarity score
		qualityWeight       = 0.3  // Weight for quality score
		recencyWeight       = 0.2  // Weight for recency score
		recencyHalfLifeDays = 30.0 // Half-life for recency decay in days
		scoreMin            = -10.0
		scoreMax            = 10.0
	)

	now := time.Now()
	type rankedMemory struct {
		memory     *memory.AgentMemory
		finalScore float64
	}
	var ranked []rankedMemory

	for _, mem := range candidates {
		if mem.Score < minQualityScore {
			continue
		}

		similarity := calculateCosineSimilarity(queryEmbedding, mem.QueryEmbedding)
		quality := (mem.Score - scoreMin) / (scoreMax - scoreMin)
		recency := calculateRecencyScore(mem.LastUsedAt, now, recencyHalfLifeDays)

		finalScore := similarityWeight*similarity +
			qualityWeight*quality +
			recencyWeight*recency

		ranked = append(ranked, rankedMemory{
			memory:     mem,
			finalScore: finalScore,
		})
	}

	sort.Slice(ranked, func(i, j int) bool {
		return ranked[i].finalScore > ranked[j].finalScore
	})

	resultSize := limit
	if len(ranked) < resultSize {
		resultSize = len(ranked)
	}

	results := make([]*memory.AgentMemory, resultSize)
	for i := 0; i < resultSize; i++ {
		results[i] = ranked[i].memory
	}

	return results
}