quietlight/skraak_mcp - Change WY2EPG7IXF67RR4R7VVDH4CYXNSEISFCRS5UPUQNZNAVOSNQATNQC

some tidy up using claude

Created by quietlight yesterday at 16:51

WY2EPG7IXF67RR4R7VVDH4CYXNSEISFCRS5UPUQNZNAVOSNQATNQC

Dependencies

In channels

main

Change contents

Replacement in utils/cluster_import.go at line 44 [3.1]

B:BD[3.978] → [3.978:1070]

// locationData holds location information needed for processing
type locationData struct {

[3.978]

[3.1070]

// LocationData holds location information needed for processing
type LocationData struct {

Deletion in utils/cluster_import.go at line 89 [3.1]

B:BD[3.2416] → [4.2493:2594]

// ImportCluster imports all WAV files from a folder into a database cluster with transaction safety

Replacement in utils/cluster_import.go at line 105 [3.1]

B:BD[3.2838] → [3.2838:2904]

	locationData, err := getLocationData(database, input.LocationID)

[3.2838]

[3.2904]

	locationData, err := GetLocationData(database, input.LocationID)

Replacement in utils/cluster_import.go at line 165 [3.1]

B:BD[3.4319] → [3.4319:4487]

// getLocationData retrieves location coordinates and timezone
func getLocationData(database *sql.DB, locationID string) (*locationData, error) {
	var loc locationData

[3.4319]

[3.4487]

// GetLocationData retrieves location coordinates and timezone
func GetLocationData(database *sql.DB, locationID string) (*LocationData, error) {
	var loc LocationData

Deletion in utils/cluster_import.go at line 181 [3.1]
B:BD[3.4841] → [4.2595:2670]
```
// EnsureClusterPath updates cluster with the folder path for file imports
```

Replacement in utils/cluster_import.go at line 267 [3.1]

B:BD[3.6953] → [3.6953:7054]

func batchProcessFiles(wavFiles []string, location *locationData) ([]*fileData, []FileImportError) {

[3.6953]

[3.7054]

func batchProcessFiles(wavFiles []string, location *LocationData) ([]*fileData, []FileImportError) {

Deletion in tools/time.go at line 20 [5.42703]
B:BD[5.43305] → [6.12305:12381]
```
// GetCurrentTime returns the current system time with timezone information
```
Deletion in tools/sql.go at line 20 [5.43910]
B:BD[5.44256] → [4.3346:3406]
```
// SetDBPath sets the database path for all tool operations
```

Replacement in tools/import_files.go at line 20 [5.50297]

B:BD[5.51033] → [5.51033:51138]

	Recursive  *bool  `json:"recursive,omitempty" jsonschema:"Scan subfolders recursively (default: true)"`

[5.51033]

[5.51138]

	Recursive  *bool  `json:"recursive,omitempty" jsonschema:"Scan subfolders recursively (default: true)"` // *bool because default is true; plain bool would make "not provided" indistinguishable from "false"

Deletion in tools/import_files.go at line 41 [5.50297]
B:BD[5.52607] → [6.18311:18381]
```
// ImportAudioFiles imports WAV files from a folder into the database
```
Deletion in tools/import_files.go at line 105 [5.50297]
B:BD[5.55191] → [7.19819:19879]
B:BD[7.19879] → [8.16202:16280]
∅:D[8.16280] → [7.19951:19967]
B:BD[7.19951] → [7.19951:19967]
B:BD[7.19967] → [8.16281:16361]
∅:D[8.16361] → [7.20041:20057]
B:BD[7.20041] → [7.20041:20057]
B:BD[7.20057] → [8.16362:16440]
∅:D[8.16440] → [7.20129:20146]
B:BD[7.20129] → [7.20129:20146]
```
	// Validate ID formats first (fast fail before DB queries)
	if err := utils.ValidateShortID(input.DatasetID, "dataset_id"); err != nil {
		return err
	}
	if err := utils.ValidateShortID(input.LocationID, "location_id"); err != nil {
		return err
	}
	if err := utils.ValidateShortID(input.ClusterID, "cluster_id"); err != nil {
		return err
	}
```

Insertion in tools/import_files.go at line 112 [5.50297]

[5.55419]

	}
	return validateHierarchyIDs(input.DatasetID, input.LocationID, input.ClusterID, dbPath)
}
// validateHierarchyIDs validates dataset/location/cluster ID formats and database relationships
func validateHierarchyIDs(datasetID, locationID, clusterID, dbPath string) error {
	// Validate ID formats first (fast fail before DB queries)
	if err := utils.ValidateShortID(datasetID, "dataset_id"); err != nil {
		return err
	}
	if err := utils.ValidateShortID(locationID, "location_id"); err != nil {
		return err
	}
	if err := utils.ValidateShortID(clusterID, "cluster_id"); err != nil {
		return err

Replacement in tools/import_files.go at line 139 [5.50297]

B:BD[5.55659] → [5.55659:55793]

	err = database.QueryRow("SELECT EXISTS(SELECT 1 FROM dataset WHERE id = ? AND active = true)", input.DatasetID).Scan(&datasetExists)

[5.55659]

[5.55793]

	err = database.QueryRow("SELECT EXISTS(SELECT 1 FROM dataset WHERE id = ? AND active = true)", datasetID).Scan(&datasetExists)

Replacement in tools/import_files.go at line 144 [5.50297]

B:BD[5.55890] → [5.55890:55964]

		return fmt.Errorf("dataset not found or inactive: %s", input.DatasetID)

[5.55890]

[5.55964]

		return fmt.Errorf("dataset not found or inactive: %s", datasetID)

Replacement in tools/import_files.go at line 148 [5.50297]

B:BD[9.1335] → [9.1335:1422]

	if err := utils.ValidateDatasetTypeForImport(database, input.DatasetID); err != nil {

[9.1335]

[9.1422]

	if err := utils.ValidateDatasetTypeForImport(database, datasetID); err != nil {

Replacement in tools/import_files.go at line 154 [5.50297]

B:BD[5.56048] → [5.56048:56182]

	err = database.QueryRow("SELECT dataset_id FROM location WHERE id = ? AND active = true", input.LocationID).Scan(&locationDatasetID)

[5.56048]

[5.56182]

	err = database.QueryRow("SELECT dataset_id FROM location WHERE id = ? AND active = true", locationID).Scan(&locationDatasetID)

Replacement in tools/import_files.go at line 156 [5.50297]

B:BD[5.56209] → [5.56209:56285]

		return fmt.Errorf("location not found or inactive: %s", input.LocationID)

[5.56209]

[5.56285]

		return fmt.Errorf("location not found or inactive: %s", locationID)

Replacement in tools/import_files.go at line 161 [5.50297]

B:BD[5.56365] → [5.56365:56508]

	if locationDatasetID != input.DatasetID {
		return fmt.Errorf("location %s does not belong to dataset %s", input.LocationID, input.DatasetID)

[5.56365]

[5.56508]

	if locationDatasetID != datasetID {
		return fmt.Errorf("location %s does not belong to dataset %s", locationID, datasetID)

Replacement in tools/import_files.go at line 167 [5.50297]

B:BD[5.56592] → [5.56592:56725]

	err = database.QueryRow("SELECT location_id FROM cluster WHERE id = ? AND active = true", input.ClusterID).Scan(&clusterLocationID)

[5.56592]

[5.56725]

	err = database.QueryRow("SELECT location_id FROM cluster WHERE id = ? AND active = true", clusterID).Scan(&clusterLocationID)

Replacement in tools/import_files.go at line 169 [5.50297]

B:BD[5.56752] → [5.56752:56826]

		return fmt.Errorf("cluster not found or inactive: %s", input.ClusterID)

[5.56752]

[5.56826]

		return fmt.Errorf("cluster not found or inactive: %s", clusterID)

Replacement in tools/import_files.go at line 174 [5.50297]

B:BD[5.56905] → [5.56905:57049]

	if clusterLocationID != input.LocationID {
		return fmt.Errorf("cluster %s does not belong to location %s", input.ClusterID, input.LocationID)

[5.56905]

[5.57049]

	if clusterLocationID != locationID {
		return fmt.Errorf("cluster %s does not belong to location %s", clusterID, locationID)

Insertion in tools/import_file.go at line 5 [10.1]
[10.37]
[10.53]
```
	"database/sql"
```

Deletion in tools/import_file.go at line 36 [10.1]

B:BD[10.1609] → [3.16517:16990]

}
// locationData holds location information (local wrapper around utils types)
type locationData struct {
	Latitude   float64
	Longitude  float64
	TimezoneID string
}
// fileData holds file metadata (local wrapper around utils types)
type fileData struct {
	FileName       string
	Hash           string
	Duration       float64
	SampleRate     int
	TimestampLocal time.Time
	IsAudioMoth    bool
	MothData       *utils.AudioMothData
	AstroData      utils.AstronomicalData

Deletion in tools/import_file.go at line 38 [10.1]

B:BD[10.1612] → [2.34:122]

// ImportFile imports a single WAV file into the database with full metadata extraction

Replacement in tools/import_file.go at line 54 [10.1]

B:BD[10.2196] → [10.2196:2437]

	if err := validateImportInput(ImportAudioFilesInput{
		DatasetID:  input.DatasetID,
		LocationID: input.LocationID,
		ClusterID:  input.ClusterID,
		FolderPath: filepath.Dir(input.FilePath), // For validation only
	}, dbPath); err != nil {

[10.2196]

[6.18886]

	if err := validateHierarchyIDs(input.DatasetID, input.LocationID, input.ClusterID, dbPath); err != nil {

Replacement in tools/import_file.go at line 58 [10.1]

B:BD[10.2514] → [10.2514:2639]

	// Phase 3: Get location data for astronomical calculations
	locationData, err := getLocationData(dbPath, input.LocationID)

[10.2514]

[10.2639]

	// Phase 3: Open database connection (single connection for all DB operations)
	database, err := db.OpenWriteableDB(dbPath)
	if err != nil {
		return output, fmt.Errorf("database connection failed: %w", err)
	}
	defer database.Close()
	// Phase 4: Get location data for astronomical calculations
	locData, err := utils.GetLocationData(database, input.LocationID)

Replacement in tools/import_file.go at line 71 [10.1]

B:BD[10.2733] → [10.2733:2828]

	// Phase 4: Process file metadata
	fileData, err := processFile(input.FilePath, locationData)

[10.2733]

[10.2828]

	// Phase 5: Process file metadata
	result, err := utils.ProcessSingleFile(input.FilePath, locData.Latitude, locData.Longitude, locData.TimezoneID, true)

Replacement in tools/import_file.go at line 81 [10.1]

B:BD[10.3067] → [10.3067:3303]

	output.FileName = fileData.FileName
	output.Hash = fileData.Hash
	output.Duration = fileData.Duration
	output.SampleRate = fileData.SampleRate
	output.TimestampLocal = fileData.TimestampLocal
	output.IsAudioMoth = fileData.IsAudioMoth

[10.3067]

[10.3303]

	output.FileName = result.FileName
	output.Hash = result.Hash
	output.Duration = result.Duration
	output.SampleRate = result.SampleRate
	output.TimestampLocal = result.TimestampLocal
	output.IsAudioMoth = result.IsAudioMoth

Replacement in tools/import_file.go at line 88 [10.1]

B:BD[10.3304] → [10.3304:3442]

	// Phase 5: Ensure cluster path is set
	if err := ensureClusterPath(dbPath, input.ClusterID, filepath.Dir(input.FilePath)); err != nil {

[10.3304]

[6.19088]

	// Phase 6: Ensure cluster path is set
	if err := utils.EnsureClusterPath(database, input.ClusterID, filepath.Dir(input.FilePath)); err != nil {

Replacement in tools/import_file.go at line 93 [10.1]

B:BD[10.3518] → [10.3518:3682]

	// Phase 6: Insert into database
	fileID, isDuplicate, err := insertFileIntoDB(
		dbPath,
		fileData,
		input.DatasetID,
		input.ClusterID,
		input.LocationID,
	)

[10.3518]

[10.3682]

	// Phase 7: Insert into database
	fileID, isDuplicate, err := insertFileIntoDB(ctx, database, result, input.DatasetID, input.ClusterID, input.LocationID)

Deletion in tools/import_file.go at line 139 [10.1]

B:BD[10.4887] → [10.4887:5022]

B:BD[10.5022] → [11.8854:8970]

∅:D[11.8970] → [10.5254:5271]

B:BD[10.5254] → [10.5254:5271]

B:BD[10.5271] → [11.8971:8989]

∅:D[11.8989] → [10.5332:5336]

B:BD[10.5332] → [10.5332:5336]

B:BD[10.6855] → [10.6855:6874]

B:BD[10.6874] → [11.8990:9278]

∅:D[11.9278] → [10.7139:7150]

B:BD[10.7139] → [10.7139:7150]

// processFile extracts all metadata from a single file
func processFile(filePath string, location *locationData) (*fileData, error) {
	result, err := utils.ProcessSingleFile(filePath, location.Latitude, location.Longitude, location.TimezoneID, true)
	if err != nil {
		return nil, err
	}
	return &fileData{
		FileName:       result.FileName,
		Hash:           result.Hash,
		Duration:       result.Duration,
		SampleRate:     result.SampleRate,
		TimestampLocal: result.TimestampLocal,
		IsAudioMoth:    result.IsAudioMoth,
		MothData:       result.MothData,
		AstroData:      result.AstroData,
	}, nil
}

Replacement in tools/import_file.go at line 142 [10.1]

B:BD[10.7273] → [10.7273:7310]

	dbPath string,
	fileData *fileData,

[10.7273]

[10.7310]

	ctx context.Context,
	database *sql.DB,
	result *utils.FileProcessingResult,

Deletion in tools/import_file.go at line 147 [10.1]

B:BD[10.7378] → [10.7378:7562]

	// Open writable database
	database, err := db.OpenWriteableDB(dbPath)
	if err != nil {
		return "", false, fmt.Errorf("failed to open database: %w", err)
	}
	defer database.Close()

Deletion in tools/import_file.go at line 148 [10.1]
∅:D[12.20805] → [10.7584:7613]
B:BD[10.7584] → [10.7584:7613]
```
	ctx := context.Background()
```

Replacement in tools/import_file.go at line 155 [10.1]

B:BD[10.7823] → [11.9279:9350]

	existingID, isDup, err := utils.CheckDuplicateHash(tx, fileData.Hash)

[10.7823]

[11.9350]

	existingID, isDup, err := utils.CheckDuplicateHash(tx, result.Hash)

Replacement in tools/import_file.go at line 177 [10.1]

B:BD[10.8850] → [10.8850:9078]

		fileID, fileData.FileName, fileData.Hash, locationID,
		fileData.TimestampLocal, clusterID, fileData.Duration, fileData.SampleRate,
		fileData.AstroData.SolarNight, fileData.AstroData.CivilNight, fileData.AstroData.MoonPhase,

[10.8850]

[10.9078]

		fileID, result.FileName, result.Hash, locationID,
		result.TimestampLocal, clusterID, result.Duration, result.SampleRate,
		result.AstroData.SolarNight, result.AstroData.CivilNight, result.AstroData.MoonPhase,

Replacement in tools/import_file.go at line 195 [10.1]

B:BD[10.9488] → [10.9488:9543]

	if fileData.IsAudioMoth && fileData.MothData != nil {

[10.9488]

[10.9543]

	if result.IsAudioMoth && result.MothData != nil {

Replacement in tools/import_file.go at line 203 [10.1]

B:BD[10.9774] → [10.9774:9929]

			fileData.MothData.Timestamp,
			&fileData.MothData.RecorderID,
			&fileData.MothData.Gain,
			&fileData.MothData.BatteryV,
			&fileData.MothData.TempC,

[10.9774]

[10.9929]

			result.MothData.Timestamp,
			&result.MothData.RecorderID,
			&result.MothData.Gain,
			&result.MothData.BatteryV,
			&result.MothData.TempC,

Deletion in tools/import_file.go at line 220 [10.1]

B:BD[10.10190] → [10.10190:10192]

B:BD[10.10192] → [3.16991:17546]

}
// getLocationData retrieves location coordinates and timezone from database
func getLocationData(dbPath, locationID string) (*locationData, error) {
	database, err := db.OpenReadOnlyDB(dbPath)
	if err != nil {
		return nil, err
	}
	defer database.Close()
	var loc locationData
	err = database.QueryRow(
		"SELECT latitude, longitude, timezone_id FROM location WHERE id = ?",
		locationID,
	).Scan(&loc.Latitude, &loc.Longitude, &loc.TimezoneID)
	if err != nil {
		return nil, fmt.Errorf("failed to query location data: %w", err)
	}
	return &loc, nil

Deletion in tools/import_file.go at line 221 [10.1]

B:BD[3.17548] → [3.17548:17906]


// ensureClusterPath sets the cluster's path field if it's currently empty
func ensureClusterPath(dbPath, clusterID, folderPath string) error {
	database, err := db.OpenWriteableDB(dbPath)
	if err != nil {
		return fmt.Errorf("failed to open database: %w", err)
	}
	defer database.Close()
	return utils.EnsureClusterPath(database, clusterID, folderPath)
}