quietlight/skraak_mcp - Change 47GPFVLW7RWBBHHUZYMEEYWG3KBJBWELR7RDKMJRWMNRWYJUBR7QC

moved validation.go to utils

Created by quietlight on February 13, 2026

47GPFVLW7RWBBHHUZYMEEYWG3KBJBWELR7RDKMJRWMNRWYJUBR7QC

Dependencies

In channels

main

Change contents

File addition: validation_test.go (----------)

[4.1]

package utils
import (
	"testing"
)
func TestValidateShortID(t *testing.T) {
	tests := []struct {
		name      string
		id        string
		fieldName string
		wantErr   bool
	}{
		{"valid 12-char ID", "abc123XYZ789", "test_id", false},
		{"valid with underscore", "abc_123_XYZ_", "test_id", false},
		{"valid with dash", "abc-123-XYZ-", "test_id", false},
		{"empty string", "", "test_id", true},
		{"too short", "abc123", "test_id", true},
		{"too long", "abc123XYZ789toolong", "test_id", true},
		{"invalid chars", "abc@123#XYZ$", "test_id", true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateShortID(tt.id, tt.fieldName)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateShortID() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateLongID(t *testing.T) {
	tests := []struct {
		name      string
		id        string
		fieldName string
		wantErr   bool
	}{
		{"valid 21-char ID", "abc123XYZ789abc123XYZ", "test_id", false}, // exactly 21 chars
		{"valid with underscore", "abc_123_XYZ_789_abc_X", "test_id", false}, // exactly 21 chars
		{"empty string", "", "test_id", true},
		{"too short", "abc123XYZ789", "test_id", true}, // 12 chars
		{"too long", "abc123XYZ789abc123XYZ789ex", "test_id", true}, // 24 chars
		{"invalid chars", "abc@123#XYZ$789%abc^XY", "test_id", true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateLongID(tt.id, tt.fieldName)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateLongID() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateStringLength(t *testing.T) {
	tests := []struct {
		name     string
		value    string
		field    string
		maxLen   int
		wantErr  bool
	}{
		{"within limit", "hello", "test", 10, false},
		{"at limit", "1234567890", "test", 10, false},
		{"empty string", "", "test", 10, false},
		{"over limit", "12345678901", "test", 10, true},
		{"zero max", "a", "test", 0, true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateStringLength(tt.value, tt.field, tt.maxLen)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateStringLength() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateRange(t *testing.T) {
	t.Run("int range", func(t *testing.T) {
		tests := []struct {
			name    string
			value   int
			min     int
			max     int
			wantErr bool
		}{
			{"within range", 50, 0, 100, false},
			{"at min", 0, 0, 100, false},
			{"at max", 100, 0, 100, false},
			{"below min", -1, 0, 100, true},
			{"above max", 101, 0, 100, true},
		}
		for _, tt := range tests {
			t.Run(tt.name, func(t *testing.T) {
				err := ValidateRange(tt.value, "test", tt.min, tt.max)
				if (err != nil) != tt.wantErr {
					t.Errorf("ValidateRange() error = %v, wantErr %v", err, tt.wantErr)
				}
			})
		}
	})
	t.Run("float64 range", func(t *testing.T) {
		tests := []struct {
			name    string
			value   float64
			min     float64
			max     float64
			wantErr bool
		}{
			{"within range", 45.5, -90.0, 90.0, false},
			{"at min", -90.0, -90.0, 90.0, false},
			{"at max", 90.0, -90.0, 90.0, false},
			{"below min", -90.1, -90.0, 90.0, true},
			{"above max", 90.1, -90.0, 90.0, true},
		}
		for _, tt := range tests {
			t.Run(tt.name, func(t *testing.T) {
				err := ValidateRange(tt.value, "test", tt.min, tt.max)
				if (err != nil) != tt.wantErr {
					t.Errorf("ValidateRange() error = %v, wantErr %v", err, tt.wantErr)
				}
			})
		}
	})
}
func TestValidatePositive(t *testing.T) {
	tests := []struct {
		name    string
		value   int
		wantErr bool
	}{
		{"positive", 1, false},
		{"large positive", 1000000, false},
		{"zero", 0, true},
		{"negative", -1, true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidatePositive(tt.value, "test")
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidatePositive() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateSampleRate(t *testing.T) {
	tests := []struct {
		name    string
		rate    int
		wantErr bool
	}{
		{"valid low", 1000, false},
		{"valid typical", 48000, false},
		{"valid high", 250000, false},
		{"valid max", 500000, false},
		{"too low", 999, true},
		{"too high", 500001, true},
		{"zero", 0, true},
		{"negative", -1000, true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateSampleRate(tt.rate)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateSampleRate() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateHash(t *testing.T) {
	tests := []struct {
		name    string
		hash    string
		wantErr bool
	}{
		{"valid hash", "0123456789abcdef", false},
		{"valid all letters", "abcdefabcdefabcd", false},
		{"valid all numbers", "1234567890123456", false},
		{"too short", "0123456789abcde", true},
		{"too long", "0123456789abcdef0", true},
		{"invalid chars", "ghijklmnopqrstuv", true},
		{"uppercase", "ABCDEF1234567890", true},
		{"mixed case", "aBcDeF1234567890", true},
		{"empty", "", true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateHash(tt.hash, "test_hash")
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateHash() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateFrequencyRange(t *testing.T) {
	low := func(v float64) *float64 { return &v }
	high := func(v float64) *float64 { return &v }
	tests := []struct {
		name    string
		freqLow *float64
		freqHigh *float64
		wantErr bool
	}{
		{"both nil", nil, nil, false},
		{"valid range", low(100.0), high(1000.0), false},
		{"valid low only", low(100.0), nil, false},
		{"valid high only", nil, high(1000.0), false},
		{"at bounds", low(0.0), high(299999.0), false},
		{"low negative", low(-1.0), high(1000.0), true},
		{"high too high", low(100.0), high(300000.0), true},
		{"low equals high", low(500.0), high(500.0), true},
		{"low greater than high", low(1000.0), high(100.0), true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateFrequencyRange(tt.freqLow, tt.freqHigh)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateFrequencyRange() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateCertainty(t *testing.T) {
	val := func(v float64) *float64 { return &v }
	tests := []struct {
		name      string
		certainty *float64
		wantErr   bool
	}{
		{"nil", nil, false},
		{"zero", val(0.0), false},
		{"mid range", val(50.0), false},
		{"100", val(100.0), false},
		{"negative", val(-0.1), true},
		{"over 100", val(100.1), true},
		{"much over", val(200.0), true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateCertainty(tt.certainty)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateCertainty() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateTimezone(t *testing.T) {
	tests := []struct {
		name    string
		tz      string
		wantErr bool
	}{
		{"valid Auckland", "Pacific/Auckland", false},
		{"valid UTC", "UTC", false},
		{"valid America/New_York", "America/New_York", false},
		{"valid Europe/London", "Europe/London", false},
		{"invalid", "Invalid/Timezone", true},
		{"garbage", "not-a-timezone", true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateTimezone(tt.tz)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateTimezone() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateNonNegative(t *testing.T) {
	tests := []struct {
		name    string
		value   int
		wantErr bool
	}{
		{"positive", 1, false},
		{"zero", 0, false},
		{"negative", -1, true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateNonNegative(tt.value, "test")
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateNonNegative() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

File addition: validation.go (----------)

[4.1]

package utils
import (
	"database/sql"
	"fmt"
	"regexp"
	"time"
)
// ID length constants matching nanoid generation
const (
	ShortIDLen = 12 // dataset, location, cluster, pattern, species, filter, call_type
	LongIDLen  = 21 // file, selection, label, label_subtype
)
// Sample rate reasonable bounds for audio recording
const (
	MinSampleRate = 1000   // 1 kHz - below this is unlikely to be real audio
	MaxSampleRate = 500000 // 500 kHz - well above bat detectors (~250kHz)
)
// Max string lengths from schema
const (
	MaxNameLen        = 140  // location.name, cluster.name
	MaxDatasetNameLen = 255  // dataset.name
	MaxDescriptionLen = 255  // all description fields
	MaxPathLen        = 255  // cluster.path
	MaxFileNameLen    = 255  // file.file_name
	MaxTimezoneLen    = 40   // location.timezone_id
	HashLen           = 16   // xxh64_hash
)
// ID format regex - alphanumeric characters (nanoid uses A-Za-z0-9_)
var shortIDRegex = regexp.MustCompile(`^[A-Za-z0-9_-]{12}$`)
var longIDRegex = regexp.MustCompile(`^[A-Za-z0-9_-]{21}$`)
var hashRegex = regexp.MustCompile(`^[0-9a-f]{16}$`)
// ValidateShortID validates 12-character nanoid format
func ValidateShortID(id, fieldName string) error {
	if id == "" {
		return fmt.Errorf("%s cannot be empty", fieldName)
	}
	if len(id) != ShortIDLen {
		return fmt.Errorf("%s must be exactly %d characters (got %d)", fieldName, ShortIDLen, len(id))
	}
	if !shortIDRegex.MatchString(id) {
		return fmt.Errorf("%s has invalid format (expected alphanumeric nanoid)", fieldName)
	}
	return nil
}
// ValidateLongID validates 21-character nanoid format
func ValidateLongID(id, fieldName string) error {
	if id == "" {
		return fmt.Errorf("%s cannot be empty", fieldName)
	}
	if len(id) != LongIDLen {
		return fmt.Errorf("%s must be exactly %d characters (got %d)", fieldName, LongIDLen, len(id))
	}
	if !longIDRegex.MatchString(id) {
		return fmt.Errorf("%s has invalid format (expected alphanumeric nanoid)", fieldName)
	}
	return nil
}
// ValidateOptionalShortID validates short ID if provided (non-empty)
func ValidateOptionalShortID(id *string, fieldName string) error {
	if id == nil || *id == "" {
		return nil
	}
	return ValidateShortID(*id, fieldName)
}
// ValidateOptionalLongID validates long ID if provided (non-empty)
func ValidateOptionalLongID(id *string, fieldName string) error {
	if id == nil || *id == "" {
		return nil
	}
	return ValidateLongID(*id, fieldName)
}
// ValidateStringLength validates string length constraint
func ValidateStringLength(value, fieldName string, maxLen int) error {
	if len(value) > maxLen {
		return fmt.Errorf("%s must be %d characters or less (got %d)", fieldName, maxLen, len(value))
	}
	return nil
}
// ValidateOptionalStringLength validates string length if provided
func ValidateOptionalStringLength(value *string, fieldName string, maxLen int) error {
	if value == nil || *value == "" {
		return nil
	}
	return ValidateStringLength(*value, fieldName, maxLen)
}
// ValidateRange validates numeric range constraint (inclusive)
func ValidateRange[T int | float64](value T, fieldName string, min, max T) error {
	if value < min || value > max {
		return fmt.Errorf("%s must be between %v and %v (got %v)", fieldName, min, max, value)
	}
	return nil
}
// ValidatePositive validates positive number (> 0)
func ValidatePositive[T int | float64](value T, fieldName string) error {
	if value <= 0 {
		return fmt.Errorf("%s must be positive (got %v)", fieldName, value)
	}
	return nil
}
// ValidateNonNegative validates non-negative number (>= 0)
func ValidateNonNegative[T int | float64](value T, fieldName string) error {
	if value < 0 {
		return fmt.Errorf("%s must be non-negative (got %v)", fieldName, value)
	}
	return nil
}
// ValidateSampleRate validates audio sample rate is in reasonable range
func ValidateSampleRate(rate int) error {
	return ValidateRange(rate, "sample_rate", MinSampleRate, MaxSampleRate)
}
// ValidateTimezone validates IANA timezone ID
func ValidateTimezone(tzID string) error {
	if _, err := time.LoadLocation(tzID); err != nil {
		return fmt.Errorf("invalid timezone_id '%s': %w", tzID, err)
	}
	return nil
}
// ValidateHash validates XXH64 hash format (16 hex characters)
func ValidateHash(hash, fieldName string) error {
	if len(hash) != HashLen {
		return fmt.Errorf("%s must be exactly %d characters (got %d)", fieldName, HashLen, len(hash))
	}
	if !hashRegex.MatchString(hash) {
		return fmt.Errorf("%s has invalid format (expected 16 hex characters)", fieldName)
	}
	return nil
}
// ValidateFrequencyRange validates frequency bounds for selections
func ValidateFrequencyRange(freqLow, freqHigh *float64) error {
	if freqLow == nil && freqHigh == nil {
		return nil
	}
	// Schema limit is 300000 Hz
	const maxFreq = 300000.0
	if freqLow != nil {
		if *freqLow < 0 {
			return fmt.Errorf("freq_low must be non-negative (got %v)", *freqLow)
		}
		if *freqLow >= maxFreq {
			return fmt.Errorf("freq_low must be less than %v Hz (got %v)", maxFreq, *freqLow)
		}
	}
	if freqHigh != nil {
		if *freqHigh < 0 {
			return fmt.Errorf("freq_high must be non-negative (got %v)", *freqHigh)
		}
		if *freqHigh >= maxFreq {
			return fmt.Errorf("freq_high must be less than %v Hz (got %v)", maxFreq, *freqHigh)
		}
	}
	// If both provided, low must be less than high
	if freqLow != nil && freqHigh != nil && *freqLow >= *freqHigh {
		return fmt.Errorf("freq_low (%v) must be less than freq_high (%v)", *freqLow, *freqHigh)
	}
	return nil
}
// ValidateCertainty validates certainty percentage (0-100)
func ValidateCertainty(certainty *float64) error {
	if certainty == nil {
		return nil
	}
	if *certainty < 0 || *certainty > 100 {
		return fmt.Errorf("certainty must be between 0 and 100 (got %v)", *certainty)
	}
	return nil
}
// EntityExists checks if an entity exists in the database
func EntityExists(db *sql.DB, table, id string) (bool, error) {
	var exists bool
	query := fmt.Sprintf("SELECT EXISTS(SELECT 1 FROM %s WHERE id = ?)", table)
	err := db.QueryRow(query, id).Scan(&exists)
	return exists, err
}
// EntityExistsAndActive checks if an entity exists and is active
func EntityExistsAndActive(db *sql.DB, table, id string) (bool, error) {
	var exists bool
	query := fmt.Sprintf("SELECT EXISTS(SELECT 1 FROM %s WHERE id = ? AND active = true)", table)
	err := db.QueryRow(query, id).Scan(&exists)
	return exists, err
}
// GetEntityActiveStatus returns whether an entity is active (and exists)
// Returns: (exists, active, error)
func GetEntityActiveStatus(db *sql.DB, table, id string) (bool, bool, error) {
	var exists bool
	var active bool
	query := fmt.Sprintf("SELECT EXISTS(SELECT 1 FROM %s WHERE id = ?), COALESCE((SELECT active FROM %s WHERE id = ?), false)", table, table)
	err := db.QueryRow(query, id, id).Scan(&exists, &active)
	return exists, active, err
}

File deletion: validation_test.go

BF:BFD[4.22715] → [3.7940:7982]

BF:BFD[3.7982] → [3.1:1]

B:BD[3.1] → [3.2:7939]

package tools
import (
	"testing"
)
func TestValidateShortID(t *testing.T) {
	tests := []struct {
		name      string
		id        string
		fieldName string
		wantErr   bool
	}{
		{"valid 12-char ID", "abc123XYZ789", "test_id", false},
		{"valid with underscore", "abc_123_XYZ_", "test_id", false},
		{"valid with dash", "abc-123-XYZ-", "test_id", false},
		{"empty string", "", "test_id", true},
		{"too short", "abc123", "test_id", true},
		{"too long", "abc123XYZ789toolong", "test_id", true},
		{"invalid chars", "abc@123#XYZ$", "test_id", true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateShortID(tt.id, tt.fieldName)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateShortID() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateLongID(t *testing.T) {
	tests := []struct {
		name      string
		id        string
		fieldName string
		wantErr   bool
	}{
		{"valid 21-char ID", "abc123XYZ789abc123XYZ", "test_id", false}, // exactly 21 chars
		{"valid with underscore", "abc_123_XYZ_789_abc_X", "test_id", false}, // exactly 21 chars
		{"empty string", "", "test_id", true},
		{"too short", "abc123XYZ789", "test_id", true}, // 12 chars
		{"too long", "abc123XYZ789abc123XYZ789ex", "test_id", true}, // 24 chars
		{"invalid chars", "abc@123#XYZ$789%abc^XY", "test_id", true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateLongID(tt.id, tt.fieldName)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateLongID() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateStringLength(t *testing.T) {
	tests := []struct {
		name     string
		value    string
		field    string
		maxLen   int
		wantErr  bool
	}{
		{"within limit", "hello", "test", 10, false},
		{"at limit", "1234567890", "test", 10, false},
		{"empty string", "", "test", 10, false},
		{"over limit", "12345678901", "test", 10, true},
		{"zero max", "a", "test", 0, true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateStringLength(tt.value, tt.field, tt.maxLen)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateStringLength() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateRange(t *testing.T) {
	t.Run("int range", func(t *testing.T) {
		tests := []struct {
			name    string
			value   int
			min     int
			max     int
			wantErr bool
		}{
			{"within range", 50, 0, 100, false},
			{"at min", 0, 0, 100, false},
			{"at max", 100, 0, 100, false},
			{"below min", -1, 0, 100, true},
			{"above max", 101, 0, 100, true},
		}
		for _, tt := range tests {
			t.Run(tt.name, func(t *testing.T) {
				err := ValidateRange(tt.value, "test", tt.min, tt.max)
				if (err != nil) != tt.wantErr {
					t.Errorf("ValidateRange() error = %v, wantErr %v", err, tt.wantErr)
				}
			})
		}
	})
	t.Run("float64 range", func(t *testing.T) {
		tests := []struct {
			name    string
			value   float64
			min     float64
			max     float64
			wantErr bool
		}{
			{"within range", 45.5, -90.0, 90.0, false},
			{"at min", -90.0, -90.0, 90.0, false},
			{"at max", 90.0, -90.0, 90.0, false},
			{"below min", -90.1, -90.0, 90.0, true},
			{"above max", 90.1, -90.0, 90.0, true},
		}
		for _, tt := range tests {
			t.Run(tt.name, func(t *testing.T) {
				err := ValidateRange(tt.value, "test", tt.min, tt.max)
				if (err != nil) != tt.wantErr {
					t.Errorf("ValidateRange() error = %v, wantErr %v", err, tt.wantErr)
				}
			})
		}
	})
}
func TestValidatePositive(t *testing.T) {
	tests := []struct {
		name    string
		value   int
		wantErr bool
	}{
		{"positive", 1, false},
		{"large positive", 1000000, false},
		{"zero", 0, true},
		{"negative", -1, true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidatePositive(tt.value, "test")
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidatePositive() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateSampleRate(t *testing.T) {
	tests := []struct {
		name    string
		rate    int
		wantErr bool
	}{
		{"valid low", 1000, false},
		{"valid typical", 48000, false},
		{"valid high", 250000, false},
		{"valid max", 500000, false},
		{"too low", 999, true},
		{"too high", 500001, true},
		{"zero", 0, true},
		{"negative", -1000, true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateSampleRate(tt.rate)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateSampleRate() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateHash(t *testing.T) {
	tests := []struct {
		name    string
		hash    string
		wantErr bool
	}{
		{"valid hash", "0123456789abcdef", false},
		{"valid all letters", "abcdefabcdefabcd", false},
		{"valid all numbers", "1234567890123456", false},
		{"too short", "0123456789abcde", true},
		{"too long", "0123456789abcdef0", true},
		{"invalid chars", "ghijklmnopqrstuv", true},
		{"uppercase", "ABCDEF1234567890", true},
		{"mixed case", "aBcDeF1234567890", true},
		{"empty", "", true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateHash(tt.hash, "test_hash")
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateHash() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateFrequencyRange(t *testing.T) {
	low := func(v float64) *float64 { return &v }
	high := func(v float64) *float64 { return &v }
	tests := []struct {
		name    string
		freqLow *float64
		freqHigh *float64
		wantErr bool
	}{
		{"both nil", nil, nil, false},
		{"valid range", low(100.0), high(1000.0), false},
		{"valid low only", low(100.0), nil, false},
		{"valid high only", nil, high(1000.0), false},
		{"at bounds", low(0.0), high(299999.0), false},
		{"low negative", low(-1.0), high(1000.0), true},
		{"high too high", low(100.0), high(300000.0), true},
		{"low equals high", low(500.0), high(500.0), true},
		{"low greater than high", low(1000.0), high(100.0), true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateFrequencyRange(tt.freqLow, tt.freqHigh)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateFrequencyRange() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateCertainty(t *testing.T) {
	val := func(v float64) *float64 { return &v }
	tests := []struct {
		name      string
		certainty *float64
		wantErr   bool
	}{
		{"nil", nil, false},
		{"zero", val(0.0), false},
		{"mid range", val(50.0), false},
		{"100", val(100.0), false},
		{"negative", val(-0.1), true},
		{"over 100", val(100.1), true},
		{"much over", val(200.0), true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateCertainty(tt.certainty)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateCertainty() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateTimezone(t *testing.T) {
	tests := []struct {
		name    string
		tz      string
		wantErr bool
	}{
		{"valid Auckland", "Pacific/Auckland", false},
		{"valid UTC", "UTC", false},
		{"valid America/New_York", "America/New_York", false},
		{"valid Europe/London", "Europe/London", false},
		{"invalid", "Invalid/Timezone", true},
		{"garbage", "not-a-timezone", true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateTimezone(tt.tz)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateTimezone() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateNonNegative(t *testing.T) {
	tests := []struct {
		name    string
		value   int
		wantErr bool
	}{
		{"positive", 1, false},
		{"zero", 0, false},
		{"negative", -1, true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateNonNegative(tt.value, "test")
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateNonNegative() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

File deletion: validation.go

BF:BFD[4.22715] → [3.14806:14843]

BF:BFD[3.14843] → [3.7984:7984]

B:BD[3.7984] → [3.7985:14805]

package tools
import (
	"database/sql"
	"fmt"
	"regexp"
	"time"
)
// ID length constants matching nanoid generation
const (
	ShortIDLen = 12 // dataset, location, cluster, pattern, species, filter, call_type
	LongIDLen  = 21 // file, selection, label, label_subtype
)
// Sample rate reasonable bounds for audio recording
const (
	MinSampleRate = 1000   // 1 kHz - below this is unlikely to be real audio
	MaxSampleRate = 500000 // 500 kHz - well above bat detectors (~250kHz)
)
// Max string lengths from schema
const (
	MaxNameLen        = 140  // location.name, cluster.name
	MaxDatasetNameLen = 255  // dataset.name
	MaxDescriptionLen = 255  // all description fields
	MaxPathLen        = 255  // cluster.path
	MaxFileNameLen    = 255  // file.file_name
	MaxTimezoneLen    = 40   // location.timezone_id
	HashLen           = 16   // xxh64_hash
)
// ID format regex - alphanumeric characters (nanoid uses A-Za-z0-9_)
var shortIDRegex = regexp.MustCompile(`^[A-Za-z0-9_-]{12}$`)
var longIDRegex = regexp.MustCompile(`^[A-Za-z0-9_-]{21}$`)
var hashRegex = regexp.MustCompile(`^[0-9a-f]{16}$`)
// ValidateShortID validates 12-character nanoid format
func ValidateShortID(id, fieldName string) error {
	if id == "" {
		return fmt.Errorf("%s cannot be empty", fieldName)
	}
	if len(id) != ShortIDLen {
		return fmt.Errorf("%s must be exactly %d characters (got %d)", fieldName, ShortIDLen, len(id))
	}
	if !shortIDRegex.MatchString(id) {
		return fmt.Errorf("%s has invalid format (expected alphanumeric nanoid)", fieldName)
	}
	return nil
}
// ValidateLongID validates 21-character nanoid format
func ValidateLongID(id, fieldName string) error {
	if id == "" {
		return fmt.Errorf("%s cannot be empty", fieldName)
	}
	if len(id) != LongIDLen {
		return fmt.Errorf("%s must be exactly %d characters (got %d)", fieldName, LongIDLen, len(id))
	}
	if !longIDRegex.MatchString(id) {
		return fmt.Errorf("%s has invalid format (expected alphanumeric nanoid)", fieldName)
	}
	return nil
}
// ValidateOptionalShortID validates short ID if provided (non-empty)
func ValidateOptionalShortID(id *string, fieldName string) error {
	if id == nil || *id == "" {
		return nil
	}
	return ValidateShortID(*id, fieldName)
}
// ValidateOptionalLongID validates long ID if provided (non-empty)
func ValidateOptionalLongID(id *string, fieldName string) error {
	if id == nil || *id == "" {
		return nil
	}
	return ValidateLongID(*id, fieldName)
}
// ValidateStringLength validates string length constraint
func ValidateStringLength(value, fieldName string, maxLen int) error {
	if len(value) > maxLen {
		return fmt.Errorf("%s must be %d characters or less (got %d)", fieldName, maxLen, len(value))
	}
	return nil
}
// ValidateOptionalStringLength validates string length if provided
func ValidateOptionalStringLength(value *string, fieldName string, maxLen int) error {
	if value == nil || *value == "" {
		return nil
	}
	return ValidateStringLength(*value, fieldName, maxLen)
}
// ValidateRange validates numeric range constraint (inclusive)
func ValidateRange[T int | float64](value T, fieldName string, min, max T) error {
	if value < min || value > max {
		return fmt.Errorf("%s must be between %v and %v (got %v)", fieldName, min, max, value)
	}
	return nil
}
// ValidatePositive validates positive number (> 0)
func ValidatePositive[T int | float64](value T, fieldName string) error {
	if value <= 0 {
		return fmt.Errorf("%s must be positive (got %v)", fieldName, value)
	}
	return nil
}
// ValidateNonNegative validates non-negative number (>= 0)
func ValidateNonNegative[T int | float64](value T, fieldName string) error {
	if value < 0 {
		return fmt.Errorf("%s must be non-negative (got %v)", fieldName, value)
	}
	return nil
}
// ValidateSampleRate validates audio sample rate is in reasonable range
func ValidateSampleRate(rate int) error {
	return ValidateRange(rate, "sample_rate", MinSampleRate, MaxSampleRate)
}
// ValidateTimezone validates IANA timezone ID
func ValidateTimezone(tzID string) error {
	if _, err := time.LoadLocation(tzID); err != nil {
		return fmt.Errorf("invalid timezone_id '%s': %w", tzID, err)
	}
	return nil
}
// ValidateHash validates XXH64 hash format (16 hex characters)
func ValidateHash(hash, fieldName string) error {
	if len(hash) != HashLen {
		return fmt.Errorf("%s must be exactly %d characters (got %d)", fieldName, HashLen, len(hash))
	}
	if !hashRegex.MatchString(hash) {
		return fmt.Errorf("%s has invalid format (expected 16 hex characters)", fieldName)
	}
	return nil
}
// ValidateFrequencyRange validates frequency bounds for selections
func ValidateFrequencyRange(freqLow, freqHigh *float64) error {
	if freqLow == nil && freqHigh == nil {
		return nil
	}
	// Schema limit is 300000 Hz
	const maxFreq = 300000.0
	if freqLow != nil {
		if *freqLow < 0 {
			return fmt.Errorf("freq_low must be non-negative (got %v)", *freqLow)
		}
		if *freqLow >= maxFreq {
			return fmt.Errorf("freq_low must be less than %v Hz (got %v)", maxFreq, *freqLow)
		}
	}
	if freqHigh != nil {
		if *freqHigh < 0 {
			return fmt.Errorf("freq_high must be non-negative (got %v)", *freqHigh)
		}
		if *freqHigh >= maxFreq {
			return fmt.Errorf("freq_high must be less than %v Hz (got %v)", maxFreq, *freqHigh)
		}
	}
	// If both provided, low must be less than high
	if freqLow != nil && freqHigh != nil && *freqLow >= *freqHigh {
		return fmt.Errorf("freq_low (%v) must be less than freq_high (%v)", *freqLow, *freqHigh)
	}
	return nil
}
// ValidateCertainty validates certainty percentage (0-100)
func ValidateCertainty(certainty *float64) error {
	if certainty == nil {
		return nil
	}
	if *certainty < 0 || *certainty > 100 {
		return fmt.Errorf("certainty must be between 0 and 100 (got %v)", *certainty)
	}
	return nil
}
// EntityExists checks if an entity exists in the database
func EntityExists(db *sql.DB, table, id string) (bool, error) {
	var exists bool
	query := fmt.Sprintf("SELECT EXISTS(SELECT 1 FROM %s WHERE id = ?)", table)
	err := db.QueryRow(query, id).Scan(&exists)
	return exists, err
}
// EntityExistsAndActive checks if an entity exists and is active
func EntityExistsAndActive(db *sql.DB, table, id string) (bool, error) {
	var exists bool
	query := fmt.Sprintf("SELECT EXISTS(SELECT 1 FROM %s WHERE id = ? AND active = true)", table)
	err := db.QueryRow(query, id).Scan(&exists)
	return exists, err
}
// GetEntityActiveStatus returns whether an entity is active (and exists)
// Returns: (exists, active, error)
func GetEntityActiveStatus(db *sql.DB, table, id string) (bool, bool, error) {
	var exists bool
	var active bool
	query := fmt.Sprintf("SELECT EXISTS(SELECT 1 FROM %s WHERE id = ?), COALESCE((SELECT active FROM %s WHERE id = ?), false)", table, table)
	err := db.QueryRow(query, id, id).Scan(&exists, &active)
	return exists, active, err
}

Replacement in tools/pattern.go at line 46 [5.4745]

B:BD[5.6532] → [3.14869:14951]

	if err := ValidatePositive(*input.RecordSeconds, "record_seconds"); err != nil {

[5.6532]

[3.14951]

	if err := utils.ValidatePositive(*input.RecordSeconds, "record_seconds"); err != nil {

Replacement in tools/pattern.go at line 49 [5.4745]

B:BD[5.6666] → [3.14973:15053]

	if err := ValidatePositive(*input.SleepSeconds, "sleep_seconds"); err != nil {

[5.6666]

[3.15053]

	if err := utils.ValidatePositive(*input.SleepSeconds, "sleep_seconds"); err != nil {

Replacement in tools/pattern.go at line 143 [5.4745]

B:BD[3.15098] → [3.15098:15164]

	if err := ValidateShortID(patternID, "pattern_id"); err != nil {

[3.15098]

[3.15164]

	if err := utils.ValidateShortID(patternID, "pattern_id"); err != nil {

Replacement in tools/pattern.go at line 149 [5.4745]

B:BD[3.15223] → [3.15223:15306]

		if err := ValidatePositive(*input.RecordSeconds, "record_seconds"); err != nil {

[3.15223]

[3.15306]

		if err := utils.ValidatePositive(*input.RecordSeconds, "record_seconds"); err != nil {

Replacement in tools/pattern.go at line 154 [5.4745]

B:BD[3.15365] → [3.15365:15449]

		if err := ValidateNonNegative(*input.SleepSeconds, "sleep_seconds"); err != nil {

[3.15365]

[3.15449]

		if err := utils.ValidateNonNegative(*input.SleepSeconds, "sleep_seconds"); err != nil {

Replacement in tools/location.go at line 42 [5.12317]

B:BD[5.14241] → [3.15899:15985]

	if err := ValidateOptionalStringLength(input.Name, "name", MaxNameLen); err != nil {

[5.14241]

[3.15985]

	if err := utils.ValidateOptionalStringLength(input.Name, "name", utils.MaxNameLen); err != nil {

Replacement in tools/location.go at line 45 [5.12317]

B:BD[5.14380] → [3.15999:16106]

	if err := ValidateOptionalStringLength(input.Description, "description", MaxDescriptionLen); err != nil {

[5.14380]

[3.16106]

	if err := utils.ValidateOptionalStringLength(input.Description, "description", utils.MaxDescriptionLen); err != nil {

Replacement in tools/location.go at line 49 [5.12317]

B:BD[3.16148] → [3.16148:16230]

		if err := ValidateRange(*input.Latitude, "latitude", -90.0, 90.0); err != nil {

[3.16148]

[3.16230]

		if err := utils.ValidateRange(*input.Latitude, "latitude", -90.0, 90.0); err != nil {

Replacement in tools/location.go at line 54 [5.12317]

B:BD[3.16278] → [3.16278:16364]

		if err := ValidateRange(*input.Longitude, "longitude", -180.0, 180.0); err != nil {

[3.16278]

[3.16364]

		if err := utils.ValidateRange(*input.Longitude, "longitude", -180.0, 180.0); err != nil {

Replacement in tools/location.go at line 59 [5.12317]

B:BD[5.14920] → [3.16383:16480]

		if err := ValidateStringLength(*input.TimezoneID, "timezone_id", MaxTimezoneLen); err != nil {

[5.14920]

[3.16480]

		if err := utils.ValidateStringLength(*input.TimezoneID, "timezone_id", utils.MaxTimezoneLen); err != nil {

Replacement in tools/location.go at line 90 [5.12317]

B:BD[3.16537] → [3.16537:16610]

	if err := ValidateShortID(*input.DatasetID, "dataset_id"); err != nil {

[3.16537]

[3.16610]

	if err := utils.ValidateShortID(*input.DatasetID, "dataset_id"); err != nil {

Replacement in tools/location.go at line 202 [5.12317]

B:BD[3.18344] → [3.18344:18412]

	if err := ValidateShortID(locationID, "location_id"); err != nil {

[3.18344]

[3.18412]

	if err := utils.ValidateShortID(locationID, "location_id"); err != nil {

Replacement in tools/location.go at line 211 [5.12317]

B:BD[3.18481] → [3.18481:18561]

	if err := ValidateOptionalShortID(input.DatasetID, "dataset_id"); err != nil {

[3.18481]

[3.18561]

	if err := utils.ValidateOptionalShortID(input.DatasetID, "dataset_id"); err != nil {

Replacement in tools/import_ml_selections.go at line 154 [6.22689]

B:BD[3.19611] → [3.19611:19677]

	if err := ValidateShortID(datasetID, "dataset_id"); err != nil {

[3.19611]

[3.19677]

	if err := utils.ValidateShortID(datasetID, "dataset_id"); err != nil {

Replacement in tools/import_ml_selections.go at line 157 [6.22689]

B:BD[3.19693] → [3.19693:19759]

	if err := ValidateShortID(clusterID, "cluster_id"); err != nil {

[3.19693]

[3.19759]

	if err := utils.ValidateShortID(clusterID, "cluster_id"); err != nil {

Replacement in tools/import_files.go at line 107 [4.50297]

B:BD[3.19879] → [3.19879:19951]

	if err := ValidateShortID(input.DatasetID, "dataset_id"); err != nil {

[3.19879]

[3.19951]

	if err := utils.ValidateShortID(input.DatasetID, "dataset_id"); err != nil {

Replacement in tools/import_files.go at line 110 [4.50297]

B:BD[3.19967] → [3.19967:20041]

	if err := ValidateShortID(input.LocationID, "location_id"); err != nil {

[3.19967]

[3.20041]

	if err := utils.ValidateShortID(input.LocationID, "location_id"); err != nil {

Replacement in tools/import_files.go at line 113 [4.50297]

B:BD[3.20057] → [3.20057:20129]

	if err := ValidateShortID(input.ClusterID, "cluster_id"); err != nil {

[3.20057]

[3.20129]

	if err := utils.ValidateShortID(input.ClusterID, "cluster_id"); err != nil {

Replacement in tools/dataset.go at line 43 [5.22019]

B:BD[5.23708] → [3.20343:20429]

	if err := ValidateStringLength(*input.Name, "name", MaxDatasetNameLen); err != nil {

[5.23708]

[3.20429]

	if err := utils.ValidateStringLength(*input.Name, "name", utils.MaxDatasetNameLen); err != nil {

Replacement in tools/dataset.go at line 48 [5.22019]

B:BD[5.23884] → [3.20451:20558]

	if err := ValidateOptionalStringLength(input.Description, "description", MaxDescriptionLen); err != nil {

[5.23884]

[3.20558]

	if err := utils.ValidateOptionalStringLength(input.Description, "description", utils.MaxDescriptionLen); err != nil {

Replacement in tools/dataset.go at line 156 [5.22019]

B:BD[3.21637] → [3.21637:21703]

	if err := ValidateShortID(datasetID, "dataset_id"); err != nil {

[3.21637]

[3.21703]

	if err := utils.ValidateShortID(datasetID, "dataset_id"); err != nil {

Replacement in tools/dataset.go at line 161 [5.22019]

B:BD[5.26440] → [3.21729:21822]

	if err := ValidateOptionalStringLength(input.Name, "name", MaxDatasetNameLen); err != nil {

[5.26440]

[3.21822]

	if err := utils.ValidateOptionalStringLength(input.Name, "name", utils.MaxDatasetNameLen); err != nil {

Replacement in tools/dataset.go at line 164 [5.22019]

B:BD[5.26592] → [3.21844:21951]

	if err := ValidateOptionalStringLength(input.Description, "description", MaxDescriptionLen); err != nil {

[5.26592]

[3.21951]

	if err := utils.ValidateOptionalStringLength(input.Description, "description", utils.MaxDescriptionLen); err != nil {

Replacement in tools/cluster.go at line 42 [5.29033]

B:BD[5.31174] → [3.22354:22440]

	if err := ValidateOptionalStringLength(input.Name, "name", MaxNameLen); err != nil {

[5.31174]

[3.22440]

	if err := utils.ValidateOptionalStringLength(input.Name, "name", utils.MaxNameLen); err != nil {

Replacement in tools/cluster.go at line 45 [5.29033]

B:BD[3.22456] → [3.22456:22563]

	if err := ValidateOptionalStringLength(input.Description, "description", MaxDescriptionLen); err != nil {

[3.22456]

[3.22563]

	if err := utils.ValidateOptionalStringLength(input.Description, "description", utils.MaxDescriptionLen); err != nil {

Replacement in tools/cluster.go at line 48 [5.29033]

B:BD[5.31313] → [3.22577:22663]

	if err := ValidateOptionalStringLength(input.Path, "path", MaxPathLen); err != nil {

[5.31313]

[3.22663]

	if err := utils.ValidateOptionalStringLength(input.Path, "path", utils.MaxPathLen); err != nil {

Replacement in tools/cluster.go at line 52 [5.29033]

B:BD[3.22707] → [3.22707:22784]

		if err := ValidatePositive(*input.SampleRate, "sample_rate"); err != nil {

[3.22707]

[3.22784]

		if err := utils.ValidatePositive(*input.SampleRate, "sample_rate"); err != nil {

Replacement in tools/cluster.go at line 56 [5.29033]

B:BD[3.22836] → [3.22836:22900]

		if err := ValidateSampleRate(*input.SampleRate); err != nil {

[3.22836]

[3.22900]

		if err := utils.ValidateSampleRate(*input.SampleRate); err != nil {

Replacement in tools/cluster.go at line 81 [5.29033]

B:BD[3.22947] → [3.22947:23020]

	if err := ValidateShortID(*input.DatasetID, "dataset_id"); err != nil {

[3.22947]

[3.23020]

	if err := utils.ValidateShortID(*input.DatasetID, "dataset_id"); err != nil {

Replacement in tools/cluster.go at line 84 [5.29033]

B:BD[3.23044] → [3.23044:23119]

	if err := ValidateShortID(*input.LocationID, "location_id"); err != nil {

[3.23044]

[3.23119]

	if err := utils.ValidateShortID(*input.LocationID, "location_id"); err != nil {

Replacement in tools/cluster.go at line 93 [5.29033]

B:BD[3.23206] → [3.23206:23318]

	if err := ValidateOptionalShortID(input.CyclicRecordingPatternID, "cyclic_recording_pattern_id"); err != nil {

[3.23206]

[7.21565]

	if err := utils.ValidateOptionalShortID(input.CyclicRecordingPatternID, "cyclic_recording_pattern_id"); err != nil {

Replacement in tools/cluster.go at line 242 [5.29033]

B:BD[3.25421] → [3.25421:25487]

	if err := ValidateShortID(clusterID, "cluster_id"); err != nil {

[3.25421]

[3.25487]

	if err := utils.ValidateShortID(clusterID, "cluster_id"); err != nil {

Replacement in tools/cluster.go at line 252 [5.29033]

B:BD[3.25657] → [3.25657:25763]

		if err := ValidateShortID(*input.CyclicRecordingPatternID, "cyclic_recording_pattern_id"); err != nil {

[3.25657]

[3.25763]

		if err := utils.ValidateShortID(*input.CyclicRecordingPatternID, "cyclic_recording_pattern_id"); err != nil {

Replacement in tools/bulk_file_import.go at line 241 [8.1]

B:BD[3.26732] → [3.26732:26804]

	if err := ValidateShortID(input.DatasetID, "dataset_id"); err != nil {

[3.26732]

[3.26804]

	if err := utils.ValidateShortID(input.DatasetID, "dataset_id"); err != nil {

Replacement in tools/bulk_file_import.go at line 306 [8.1]

B:BD[3.26927] → [3.26927:26996]

		if err := ValidateShortID(locationID, "location_id"); err != nil {

[3.26927]

[3.26996]

		if err := utils.ValidateShortID(locationID, "location_id"); err != nil {

Replacement in tools/bulk_file_import.go at line 316 [8.1]

B:BD[3.27197] → [3.27197:27254]

		if err := ValidateSampleRate(sampleRate); err != nil {

[3.27197]

[8.9639]

		if err := utils.ValidateSampleRate(sampleRate); err != nil {

Replacement in README.md at line 99 [4.334405]

∅:D[2.29878] → [9.152854:152898]

B:BD[9.152854] → [9.152854:152898]

B:BD[9.152898] → [2.29879:30044]

- `import bulk` - Bulk import from CSV file
- `import file` - Import a single WAV file
- `import folder` - Import all WAV files from a folder
- `import selections` - Import ML selections from folder structure

[2.29878]

[2.30044]

- `import bulk` - Bulk import from CSV file (structured dataset)
- `import file` - Import a single WAV file (structured dataset)
- `import folder` - Import all WAV files from a folder (structured dataset)
- `import selections` - Import ML selections from folder structure (structured dataset)

Insertion in CLAUDE.md at line 118 [4.363912]

[4.365715]


## Package Organization Policy
### tools/ vs utils/ - When to Use Which
**`utils/`** - Pure utility functions:
- No MCP tool types (no `*Input`/`*Output` structs)
- Pure Go functions (input → output, minimal side effects)
- Can have database dependency for utility queries (e.g., `EntityExists()`)
- Reusable across tools, CLI, and other packages
- Examples: `ValidateXxx()`, `ParseFilename()`, `ComputeHash()`, `EntityExists()`
**`tools/`** - MCP tool implementations:
- MCP-specific types (`DatasetInput`, `ClusterOutput`, etc.)
- Business logic layer between CLI/MCP and database
- Orchestrates validation, database operations, and response formatting
- One file per MCP tool (e.g., `dataset.go`, `cluster.go`)
- Imports `utils/` for validation and helpers
**Decision checklist:**
1. Does it define MCP tool types? → `tools/`
2. Is it a reusable helper function? → `utils/`
3. Does multiple tools/CLI need it? → `utils/`
4. Is it specific to one MCP tool's logic? → `tools/`
**Examples:**
| Function | Package | Reason |
|----------|---------|--------|
| `ValidateShortID()` | `utils/` | Pure validation, reusable |
| `EntityExists()` | `utils/` | Database helper, reusable |
| `CreateOrUpdateDataset()` | `tools/` | MCP tool implementation |
| `ImportCluster()` | `utils/` | Reusable import logic |
| `DatasetInput` struct | `tools/` | MCP-specific type |
**Key insight:** The package boundary is about **reuse and MCP coupling**, not database dependency. `utils/` can use the database for utility queries, but it should never define MCP tool types.

Replacement in CLAUDE.md at line 204 [4.363912]

B:BD[10.75126] → [7.25992:26065]

├── tools/                        # Core logic (NO MCP dependency)

[10.75126]

[7.26065]

├── tools/                        # MCP tool implementations

Deletion in CLAUDE.md at line 207 [4.363912]
B:BD[7.26198] → [3.27325:27398]
```
│   ├── validation.go             # Application-level guardrails
```

Replacement in CLAUDE.md at line 219 [4.363912]

B:BD[4.367707] → [10.75127:75204]

├── utils/                        # Utility functions for file imports

[4.367707]

[10.75204]

├── utils/                        # Pure utility functions (reusable)

Insertion in CLAUDE.md at line 228 [4.363912]

[6.68911]

[10.75645]

│   ├── validation.go             # Input validation helpers
│   ├── validation_test.go        # Validation tests

Replacement in CLAUDE.md at line 329 [4.363912]

B:BD[3.27434] → [3.27434:27522]

**tools/validation.go** provides application-level guardrails for all write operations:

[3.27434]

[3.27522]

**utils/validation.go** provides application-level guardrails for all write operations: