quietlight/skraakCLI - Change DGGHHKY6RVX4GMFAMUURMOQAOR4PRW6GBAJXYBAOAAR6AEBW6QYQC

cyclo fails

Created by quietlight on May 18, 2026

DGGHHKY6RVX4GMFAMUURMOQAOR4PRW6GBAJXYBAOAAR6AEBW6QYQC

Dependencies

In channels

main

Change contents

Insertion in wav/wav_metadata.go at line 308 [7.25725]

[7.34525]

}
// handleFmtChunk processes the fmt chunk and updates info.
func handleFmtChunk(file *os.File, chunkSize int64, info *wavChunkInfo) error {
	fmtData := make([]byte, chunkSize)
	if _, err := io.ReadFull(file, fmtData); err != nil {
		return fmt.Errorf("failed to read fmt chunk: %w", err)
	}
	if len(fmtData) >= 16 {
		info.channels = int(binary.LittleEndian.Uint16(fmtData[2:4]))
		info.sampleRate = int(binary.LittleEndian.Uint32(fmtData[4:8]))
		info.bitsPerSample = int(binary.LittleEndian.Uint16(fmtData[14:16]))
	}
	return nil

Insertion in wav/wav_metadata.go at line 324 [7.25725]

[7.34528]

// skipUnknownChunk skips an unknown chunk and its padding.
func skipUnknownChunk(file *os.File, chunkSize int64) error {
	if _, err := file.Seek(chunkSize, io.SeekCurrent); err != nil {
		return fmt.Errorf("failed to skip chunk: %w", err)
	}
	if chunkSize%2 != 0 {
		if _, err := file.Seek(1, io.SeekCurrent); err != nil {
			return fmt.Errorf("failed to skip padding: %w", err)
		}
	}
	return nil
}

Replacement in wav/wav_metadata.go at line 355 [7.25725]

B:BD[7.35117] → [7.35117:35277]

			fmtData := make([]byte, chunkSize)
			if _, err := io.ReadFull(file, fmtData); err != nil {
				return info, fmt.Errorf("failed to read fmt chunk: %w", err)

[7.35117]

[7.35277]

			if err := handleFmtChunk(file, chunkSize, &info); err != nil {
				return info, err

Deletion in wav/wav_metadata.go at line 358 [7.25725]

B:BD[7.35282] → [7.35282:35521]

			if len(fmtData) >= 16 {
				info.channels = int(binary.LittleEndian.Uint16(fmtData[2:4]))
				info.sampleRate = int(binary.LittleEndian.Uint32(fmtData[4:8]))
				info.bitsPerSample = int(binary.LittleEndian.Uint16(fmtData[14:16]))
			}

Replacement in wav/wav_metadata.go at line 363 [7.25725]

B:BD[7.35649] → [7.35649:35777]

			if _, err := file.Seek(chunkSize, io.SeekCurrent); err != nil {
				return info, fmt.Errorf("failed to skip chunk: %w", err)

[7.35649]

[7.35777]

			if err := skipUnknownChunk(file, chunkSize); err != nil {
				return info, err

Insertion in wav/wav_metadata.go at line 366 [7.25725]
[7.35782]
[7.35782]
```
			continue
```
Insertion in wav/wav_metadata.go at line 369 [7.25725]
[7.35787]
[7.35787]
```
		// Skip padding for fmt chunk (data chunk returns above)
```

Replacement in wav/filename_parser.go at line 122 [4.12914]

B:BD[4.16667] → [4.16667:16884]

// detectDateFormat analyzes filenames to determine the date format
func detectDateFormat(filenames []string) (DateFormat, error) {
	// Extract all date parts from filenames
	var parts []dateParts
	var has8Digit bool

[4.16667]

[4.16884]

// datePartsResult holds the result of collecting date parts from filenames
type datePartsResult struct {
	parts     []dateParts
	has8Digit bool
}

Insertion in wav/filename_parser.go at line 128 [4.12914]

[4.16885]

// collectDateParts extracts date parts from filenames for format detection.
func collectDateParts(filenames []string) datePartsResult {
	var result datePartsResult

Deletion in wav/filename_parser.go at line 139 [4.12914]
B:BD[4.17083] → [4.17083:17125]
```
		// Check for 8-digit format (YYYYMMDD)
```
Replacement in wav/filename_parser.go at line 140 [4.12914]
B:BD[4.17150] → [4.17150:17170]
```
			has8Digit = true
```
[4.17150]
[4.17170]
```
			result.has8Digit = true
```
Deletion in wav/filename_parser.go at line 144 [4.12914]
B:BD[4.17187] → [4.17187:17213]
```
		// Parse 6-digit format
```

Replacement in wav/filename_parser.go at line 148 [4.12914]

B:BD[4.17354] → [4.17354:17412]

			parts = append(parts, dateParts{x1: x1, m: m, x2: x2})

[4.17354]

[4.17412]

			result.parts = append(result.parts, dateParts{x1: x1, m: m, x2: x2})

Insertion in wav/filename_parser.go at line 151 [4.12914]
[4.17419]
[4.17419]
```
	return result
}
```

Insertion in wav/filename_parser.go at line 154 [4.12914]

[4.17420]

// determineFormatFromParts determines the date format from collected parts.
func determineFormatFromParts(result datePartsResult) (DateFormat, error) {

Replacement in wav/filename_parser.go at line 157 [4.12914]
B:BD[4.17468] → [4.17468:17503]
```
	if has8Digit && len(parts) == 0 {
```
[4.17468]
[4.17503]
```
	if result.has8Digit && len(result.parts) == 0 {
```
Replacement in wav/filename_parser.go at line 162 [4.12914]
B:BD[4.17581] → [4.17581:17615]
```
	if has8Digit && len(parts) > 0 {
```
[4.17581]
[4.17615]
```
	if result.has8Digit && len(result.parts) > 0 {
```
Replacement in wav/filename_parser.go at line 167 [4.12914]
B:BD[4.17743] → [4.17743:17765]
```
	if len(parts) == 0 {
```
[4.17743]
[4.17765]
```
	if len(result.parts) == 0 {
```
Replacement in wav/filename_parser.go at line 172 [4.12914]
B:BD[4.17910] → [4.17910:17932]
```
	if len(parts) == 1 {
```
[4.17910]
[4.17932]
```
	if len(result.parts) == 1 {
```

Replacement in wav/filename_parser.go at line 177 [4.12914]

B:BD[4.18095] → [4.18095:18365]

	// Compare uniqueness of x1 (first 2 digits) vs x2 (last 2 digits)
	// Day values vary more than year values across recordings
	uniqueX1 := countUnique(parts, func(p dateParts) int { return p.x1 })
	uniqueX2 := countUnique(parts, func(p dateParts) int { return p.x2 })

[4.18095]

[4.18365]

	uniqueX1 := countUnique(result.parts, func(p dateParts) int { return p.x1 })
	uniqueX2 := countUnique(result.parts, func(p dateParts) int { return p.x2 })

Deletion in wav/filename_parser.go at line 181 [4.12914]
B:BD[4.18393] → [4.18393:18459]
```
		// x2 has more variance → likely day values → YYMMDD format
```

Deletion in wav/filename_parser.go at line 182 [4.12914]

B:BD[4.18487] → [4.18487:18591]

	} else {
		// x1 has more variance → likely day values → DDMMYY format
		return Format6DDMMYY, nil

Insertion in wav/filename_parser.go at line 183 [4.12914]

[4.18594]

	return Format6DDMMYY, nil
}
// detectDateFormat analyzes filenames to determine the date format
func detectDateFormat(filenames []string) (DateFormat, error) {
	result := collectDateParts(filenames)
	return determineFormatFromParts(result)

Insertion in utils/fs.go at line 35 [9.3220]

[8.281]

}
// shouldSkipHidden checks if a path should be skipped due to hidden file rules.
func shouldSkipHidden(name, path, rootPath string, info os.FileInfo, skipHidden bool) (bool, error) {
	if !skipHidden || !strings.HasPrefix(name, ".") || path == rootPath {
		return false, nil
	}
	if info.IsDir() {
		return true, filepath.SkipDir
	}
	return true, nil

Insertion in utils/fs.go at line 48 [9.3220]

[9.4050]

[8.284]

// shouldSkipDir checks if a directory should be skipped based on prefixes.
func shouldSkipDir(name, path, rootPath string, skipPrefixes []string) bool {
	if path == rootPath {
		return false
	}
	for _, prefix := range skipPrefixes {
		if strings.HasPrefix(name, prefix) {
			return true
		}
	}
	return false
}

Replacement in utils/fs.go at line 70 [9.3220]

B:BD[8.612] → [8.612:736]

∅:D[8.736] → [9.4464:4469]

B:BD[9.4464] → [9.4464:4469]

B:BD[9.4469] → [8.737:751]

		if opts.SkipHidden && strings.HasPrefix(name, ".") && path != rootPath {
			if info.IsDir() {
				return filepath.SkipDir
			}
			return nil

[8.612]

[8.751]

		if skip, skipErr := shouldSkipHidden(name, path, rootPath, info, opts.SkipHidden); skip {
			return skipErr

Replacement in utils/fs.go at line 75 [9.3220]

B:BD[8.791] → [8.791:947]

∅:D[8.947] → [9.4635:4641]

B:BD[9.4635] → [9.4635:4641]

		if info.IsDir() && path != rootPath {
			for _, prefix := range opts.SkipPrefixes {
				if strings.HasPrefix(name, prefix) {
					return filepath.SkipDir
				}

[8.791]

[9.4641]

		if info.IsDir() {
			if shouldSkipDir(name, path, rootPath, opts.SkipPrefixes) {
				return filepath.SkipDir

Replacement in utils/fs.go at line 83 [9.3220]

B:BD[8.964] → [8.964:1061]

∅:D[8.1061] → [9.4867:4872]

B:BD[9.4867] → [9.4867:4872]

		if !info.IsDir() {
			if fileMatches(name, info, opts) {
				*results = append(*results, path)
			}

[8.964]

[8.1062]

		if fileMatches(name, info, opts) {
			*results = append(*results, path)

Replacement in tools/import/import_unstructured_test.go at line 11 [5.11293]
B:BD[5.11380] → [5.11380:11424]
```
func TestImportUnstructured(t *testing.T) {
```
[5.11380]
[5.11424]
```
func TestImportUnstructured_HappyPath(t *testing.T) {
```
Insertion in tools/import/import_unstructured_test.go at line 13 [5.11293]
[5.11453]
[5.11453]
```
	dbPath := setupFileBasedTestDB(t)
```

Replacement in tools/import/import_unstructured_test.go at line 15 [5.11293]

B:BD[5.11454] → [5.11454:11557]

	t.Run("happy path - import single WAV file", func(t *testing.T) {
		dbPath := setupFileBasedTestDB(t)

[5.11454]

[5.11557]

	// Create temp folder with a WAV file
	tmpDir := t.TempDir()
	wavPath := filepath.Join(tmpDir, "test_recording.wav")
	hash := createTestWAV(t, wavPath)

Replacement in tools/import/import_unstructured_test.go at line 20 [5.11293]

B:BD[5.11558] → [5.11558:11715]

		// Create temp folder with a WAV file
		tmpDir := t.TempDir()
		wavPath := filepath.Join(tmpDir, "test_recording.wav")
		hash := createTestWAV(t, wavPath)

[5.11558]

[5.11715]

	// Import to unstructured dataset
	output, err := ImportUnstructured(ctx, ImportUnstructuredInput{
		DBPath:     dbPath,
		DatasetID:  "dstest000002", // unstructured dataset
		FolderPath: tmpDir,
		Recursive:  new(true),
	})
	if err != nil {
		t.Fatalf("ImportUnstructured failed: %v", err)
	}

Replacement in tools/import/import_unstructured_test.go at line 31 [5.11293]

B:BD[5.11716] → [5.11716:12022]

		// Import to unstructured dataset
		output, err := ImportUnstructured(ctx, ImportUnstructuredInput{
			DBPath:     dbPath,
			DatasetID:  "dstest000002", // unstructured dataset
			FolderPath: tmpDir,
			Recursive:  new(true),
		})
		if err != nil {
			t.Fatalf("ImportUnstructured failed: %v", err)
		}

[5.11716]

[5.12022]

	// Verify output
	if output.TotalFiles != 1 {
		t.Errorf("expected 1 total file, got %d", output.TotalFiles)
	}
	if output.ImportedFiles != 1 {
		t.Errorf("expected 1 imported file, got %d", output.ImportedFiles)
	}
	if output.SkippedFiles != 0 {
		t.Errorf("expected 0 skipped files, got %d", output.SkippedFiles)
	}
	if len(output.Errors) != 0 {
		t.Errorf("unexpected errors: %v", output.Errors)
	}

Replacement in tools/import/import_unstructured_test.go at line 45 [5.11293]

B:BD[5.12023] → [5.12023:12439]

		// Verify output
		if output.TotalFiles != 1 {
			t.Errorf("expected 1 total file, got %d", output.TotalFiles)
		}
		if output.ImportedFiles != 1 {
			t.Errorf("expected 1 imported file, got %d", output.ImportedFiles)
		}
		if output.SkippedFiles != 0 {
			t.Errorf("expected 0 skipped files, got %d", output.SkippedFiles)
		}
		if len(output.Errors) != 0 {
			t.Errorf("unexpected errors: %v", output.Errors)
		}

[5.12023]

[5.12439]

	// Verify file was inserted into database
	database, err := sql.Open("duckdb", dbPath)
	if err != nil {
		t.Fatalf("failed to open database for verification: %v", err)
	}
	defer database.Close()

Replacement in tools/import/import_unstructured_test.go at line 52 [5.11293]

B:BD[5.12440] → [5.12440:12642]

		// Verify file was inserted into database
		database, err := sql.Open("duckdb", dbPath)
		if err != nil {
			t.Fatalf("failed to open database for verification: %v", err)
		}
		defer database.Close()

[5.12440]

[5.12642]

	var fileCount int
	err = database.QueryRow("SELECT COUNT(*) FROM file WHERE xxh64_hash = ? AND active = true", hash).Scan(&fileCount)
	if err != nil {
		t.Fatalf("failed to query file: %v", err)
	}
	if fileCount != 1 {
		t.Errorf("expected 1 file in database, got %d", fileCount)
	}

Replacement in tools/import/import_unstructured_test.go at line 61 [5.11293]

B:BD[5.12643] → [5.12643:12935]

		var fileCount int
		err = database.QueryRow("SELECT COUNT(*) FROM file WHERE xxh64_hash = ? AND active = true", hash).Scan(&fileCount)
		if err != nil {
			t.Fatalf("failed to query file: %v", err)
		}
		if fileCount != 1 {
			t.Errorf("expected 1 file in database, got %d", fileCount)
		}

[5.12643]

[5.12935]

	// Verify file_dataset link
	var linkCount int
	err = database.QueryRow(`
		SELECT COUNT(*) FROM file_dataset fd
		JOIN file f ON fd.file_id = f.id
		WHERE f.xxh64_hash = ? AND fd.dataset_id = 'dstest000002'
	`, hash).Scan(&linkCount)
	if err != nil {
		t.Fatalf("failed to query file_dataset: %v", err)
	}
	if linkCount != 1 {
		t.Errorf("expected 1 file_dataset link, got %d", linkCount)
	}

Replacement in tools/import/import_unstructured_test.go at line 75 [5.11293]

B:BD[5.12936] → [5.12936:13343]

		// Verify file_dataset link
		var linkCount int
		err = database.QueryRow(`
			SELECT COUNT(*) FROM file_dataset fd
			JOIN file f ON fd.file_id = f.id
			WHERE f.xxh64_hash = ? AND fd.dataset_id = 'dstest000002'
		`, hash).Scan(&linkCount)
		if err != nil {
			t.Fatalf("failed to query file_dataset: %v", err)
		}
		if linkCount != 1 {
			t.Errorf("expected 1 file_dataset link, got %d", linkCount)
		}

[5.12936]

[5.13343]

	// Verify location_id and cluster_id are NULL for unstructured
	var locID, clID sql.NullString
	err = database.QueryRow("SELECT location_id, cluster_id FROM file WHERE xxh64_hash = ?", hash).Scan(&locID, &clID)
	if err != nil {
		t.Fatalf("failed to query file: %v", err)
	}
	if locID.Valid {
		t.Errorf("expected NULL location_id for unstructured file, got %s", locID.String)
	}
	if clID.Valid {
		t.Errorf("expected NULL cluster_id for unstructured file, got %s", clID.String)
	}
}

Replacement in tools/import/import_unstructured_test.go at line 89 [5.11293]

B:BD[5.13344] → [5.13344:13843]

		// Verify location_id and cluster_id are NULL for unstructured
		var locID, clID sql.NullString
		err = database.QueryRow("SELECT location_id, cluster_id FROM file WHERE xxh64_hash = ?", hash).Scan(&locID, &clID)
		if err != nil {
			t.Fatalf("failed to query file: %v", err)
		}
		if locID.Valid {
			t.Errorf("expected NULL location_id for unstructured file, got %s", locID.String)
		}
		if clID.Valid {
			t.Errorf("expected NULL cluster_id for unstructured file, got %s", clID.String)
		}
	})

[5.13344]

[5.13843]

func TestImportUnstructured_DuplicateHandling(t *testing.T) {
	ctx := context.Background()
	dbPath := setupFileBasedTestDB(t)

Replacement in tools/import/import_unstructured_test.go at line 93 [5.11293]

B:BD[5.13844] → [5.13844:13961]

	t.Run("duplicate handling - skip file with existing hash", func(t *testing.T) {
		dbPath := setupFileBasedTestDB(t)

[5.13844]

[5.13961]

	// Create temp folder with a WAV file
	tmpDir := t.TempDir()
	wavPath := filepath.Join(tmpDir, "test_recording.wav")
	hash := createTestWAV(t, wavPath)

Replacement in tools/import/import_unstructured_test.go at line 98 [5.11293]

B:BD[5.13962] → [5.13962:14119]

		// Create temp folder with a WAV file
		tmpDir := t.TempDir()
		wavPath := filepath.Join(tmpDir, "test_recording.wav")
		hash := createTestWAV(t, wavPath)

[5.13962]

[5.14119]

	// First import
	_, err := ImportUnstructured(ctx, ImportUnstructuredInput{
		DBPath:     dbPath,
		DatasetID:  "dstest000002",
		FolderPath: tmpDir,
		Recursive:  new(true),
	})
	if err != nil {
		t.Fatalf("first import failed: %v", err)
	}

Replacement in tools/import/import_unstructured_test.go at line 109 [5.11293]

B:BD[5.14120] → [5.14120:14373]

		// First import
		_, err := ImportUnstructured(ctx, ImportUnstructuredInput{
			DBPath:     dbPath,
			DatasetID:  "dstest000002",
			FolderPath: tmpDir,
			Recursive:  new(true),
		})
		if err != nil {
			t.Fatalf("first import failed: %v", err)
		}

[5.14120]

[5.14373]

	// Second import of same file (should be skipped as duplicate)
	output, err := ImportUnstructured(ctx, ImportUnstructuredInput{
		DBPath:     dbPath,
		DatasetID:  "dstest000002",
		FolderPath: tmpDir,
		Recursive:  new(true),
	})
	if err != nil {
		t.Fatalf("second import failed: %v", err)
	}

Replacement in tools/import/import_unstructured_test.go at line 120 [5.11293]

B:BD[5.14374] → [5.14374:14680]

		// Second import of same file (should be skipped as duplicate)
		output, err := ImportUnstructured(ctx, ImportUnstructuredInput{
			DBPath:     dbPath,
			DatasetID:  "dstest000002",
			FolderPath: tmpDir,
			Recursive:  new(true),
		})
		if err != nil {
			t.Fatalf("second import failed: %v", err)
		}

[5.14374]

[5.14680]

	// Verify output
	if output.TotalFiles != 1 {
		t.Errorf("expected 1 total file, got %d", output.TotalFiles)
	}
	if output.ImportedFiles != 0 {
		t.Errorf("expected 0 imported files (duplicate), got %d", output.ImportedFiles)
	}
	if output.SkippedFiles != 1 {
		t.Errorf("expected 1 skipped file (duplicate), got %d", output.SkippedFiles)
	}

Replacement in tools/import/import_unstructured_test.go at line 131 [5.11293]

B:BD[5.14681] → [5.14681:15034]

		// Verify output
		if output.TotalFiles != 1 {
			t.Errorf("expected 1 total file, got %d", output.TotalFiles)
		}
		if output.ImportedFiles != 0 {
			t.Errorf("expected 0 imported files (duplicate), got %d", output.ImportedFiles)
		}
		if output.SkippedFiles != 1 {
			t.Errorf("expected 1 skipped file (duplicate), got %d", output.SkippedFiles)
		}

[5.14681]

[5.15034]

	// Verify only one file in database (not duplicated)
	database, err := sql.Open("duckdb", dbPath)
	if err != nil {
		t.Fatalf("failed to open database for verification: %v", err)
	}
	defer database.Close()

Replacement in tools/import/import_unstructured_test.go at line 138 [5.11293]

B:BD[5.15035] → [5.15035:15248]

		// Verify only one file in database (not duplicated)
		database, err := sql.Open("duckdb", dbPath)
		if err != nil {
			t.Fatalf("failed to open database for verification: %v", err)
		}
		defer database.Close()

[5.15035]

[5.15248]

	var fileCount int
	err = database.QueryRow("SELECT COUNT(*) FROM file WHERE xxh64_hash = ? AND active = true", hash).Scan(&fileCount)
	if err != nil {
		t.Fatalf("failed to query file: %v", err)
	}
	if fileCount != 1 {
		t.Errorf("expected 1 file in database (not duplicated), got %d", fileCount)
	}
}

Replacement in tools/import/import_unstructured_test.go at line 148 [5.11293]

B:BD[5.15249] → [5.15249:15562]

		var fileCount int
		err = database.QueryRow("SELECT COUNT(*) FROM file WHERE xxh64_hash = ? AND active = true", hash).Scan(&fileCount)
		if err != nil {
			t.Fatalf("failed to query file: %v", err)
		}
		if fileCount != 1 {
			t.Errorf("expected 1 file in database (not duplicated), got %d", fileCount)
		}
	})

[5.15249]

[5.15562]

func TestImportUnstructured_EdgeCases(t *testing.T) {
	ctx := context.Background()

Replacement in tools/import/import_files_test.go at line 12 [5.27703]
B:BD[5.27798] → [5.27798:27840]
```
func TestImportAudioFiles(t *testing.T) {
```
[5.27798]
[5.27840]
```
func TestImportAudioFiles_HappyPath(t *testing.T) {
```
Insertion in tools/import/import_files_test.go at line 14 [5.27703]
[5.27869]
[5.27869]
```
	dbPath := setupFileBasedTestDB(t)
```

Replacement in tools/import/import_files_test.go at line 16 [5.27703]

B:BD[5.27870] → [5.27870:28050]

	t.Run("happy path - import single WAV file", func(t *testing.T) {
		dbPath := setupFileBasedTestDB(t)
		// Don't keep database open - ImportAudioFiles manages its own connections

[5.27870]

[5.28050]

	// Create temp folder with a WAV file
	tmpDir := t.TempDir()
	wavPath := filepath.Join(tmpDir, "test_recording.wav")
	hash := createTestWAV(t, wavPath)

Replacement in tools/import/import_files_test.go at line 21 [5.27703]

B:BD[5.28051] → [5.28051:28208]

		// Create temp folder with a WAV file
		tmpDir := t.TempDir()
		wavPath := filepath.Join(tmpDir, "test_recording.wav")
		hash := createTestWAV(t, wavPath)

[5.28051]

[5.28208]

	// Import
	output, err := ImportAudioFiles(ctx, ImportAudioFilesInput{
		DBPath:     dbPath,
		FolderPath: tmpDir,
		DatasetID:  "dstest000001",
		LocationID: "loctest00001",
		ClusterID:  "cltest000001",
		Recursive:  new(true),
	})
	if err != nil {
		t.Fatalf("ImportAudioFiles failed: %v", err)
	}

Replacement in tools/import/import_files_test.go at line 34 [5.27703]

B:BD[5.28209] → [5.28209:28523]

		// Import
		output, err := ImportAudioFiles(ctx, ImportAudioFilesInput{
			DBPath:     dbPath,
			FolderPath: tmpDir,
			DatasetID:  "dstest000001",
			LocationID: "loctest00001",
			ClusterID:  "cltest000001",
			Recursive:  new(true),
		})
		if err != nil {
			t.Fatalf("ImportAudioFiles failed: %v", err)
		}

[5.28209]

[5.28523]

	// Verify output
	if output.Summary.TotalFiles != 1 {
		t.Errorf("expected 1 total file, got %d", output.Summary.TotalFiles)
	}
	if output.Summary.ImportedFiles != 1 {
		t.Errorf("expected 1 imported file, got %d", output.Summary.ImportedFiles)
	}
	if output.Summary.SkippedFiles != 0 {
		t.Errorf("expected 0 skipped files, got %d", output.Summary.SkippedFiles)
	}
	if len(output.Errors) != 0 {
		t.Errorf("unexpected errors: %v", output.Errors)
	}

Replacement in tools/import/import_files_test.go at line 48 [5.27703]

B:BD[5.28524] → [5.28524:28988]

		// Verify output
		if output.Summary.TotalFiles != 1 {
			t.Errorf("expected 1 total file, got %d", output.Summary.TotalFiles)
		}
		if output.Summary.ImportedFiles != 1 {
			t.Errorf("expected 1 imported file, got %d", output.Summary.ImportedFiles)
		}
		if output.Summary.SkippedFiles != 0 {
			t.Errorf("expected 0 skipped files, got %d", output.Summary.SkippedFiles)
		}
		if len(output.Errors) != 0 {
			t.Errorf("unexpected errors: %v", output.Errors)
		}

[5.28524]

[5.28988]

	// Verify file was inserted into database - open new connection
	database, err := sql.Open("duckdb", dbPath)
	if err != nil {
		t.Fatalf("failed to open database for verification: %v", err)
	}
	defer database.Close()

Replacement in tools/import/import_files_test.go at line 55 [5.27703]

B:BD[5.28989] → [5.28989:29213]

		// Verify file was inserted into database - open new connection
		database, err := sql.Open("duckdb", dbPath)
		if err != nil {
			t.Fatalf("failed to open database for verification: %v", err)
		}
		defer database.Close()

[5.28989]

[5.29213]

	var fileCount int
	err = database.QueryRow("SELECT COUNT(*) FROM file WHERE xxh64_hash = ? AND active = true", hash).Scan(&fileCount)
	if err != nil {
		t.Fatalf("failed to query file: %v", err)
	}
	if fileCount != 1 {
		t.Errorf("expected 1 file in database, got %d", fileCount)
	}

Replacement in tools/import/import_files_test.go at line 64 [5.27703]

B:BD[5.29214] → [5.29214:29506]

		var fileCount int
		err = database.QueryRow("SELECT COUNT(*) FROM file WHERE xxh64_hash = ? AND active = true", hash).Scan(&fileCount)
		if err != nil {
			t.Fatalf("failed to query file: %v", err)
		}
		if fileCount != 1 {
			t.Errorf("expected 1 file in database, got %d", fileCount)
		}

[5.29214]

[5.29506]

	// Verify file_dataset link
	var linkCount int
	err = database.QueryRow(`
		SELECT COUNT(*) FROM file_dataset fd
		JOIN file f ON fd.file_id = f.id
		WHERE f.xxh64_hash = ? AND fd.dataset_id = 'dstest000001'
	`, hash).Scan(&linkCount)
	if err != nil {
		t.Fatalf("failed to query file_dataset: %v", err)
	}
	if linkCount != 1 {
		t.Errorf("expected 1 file_dataset link, got %d", linkCount)
	}
}

Replacement in tools/import/import_files_test.go at line 79 [5.27703]

B:BD[5.29507] → [5.29507:29918]

		// Verify file_dataset link
		var linkCount int
		err = database.QueryRow(`
			SELECT COUNT(*) FROM file_dataset fd
			JOIN file f ON fd.file_id = f.id
			WHERE f.xxh64_hash = ? AND fd.dataset_id = 'dstest000001'
		`, hash).Scan(&linkCount)
		if err != nil {
			t.Fatalf("failed to query file_dataset: %v", err)
		}
		if linkCount != 1 {
			t.Errorf("expected 1 file_dataset link, got %d", linkCount)
		}
	})

[5.29507]

[5.29918]

func TestImportAudioFiles_DuplicateHandling(t *testing.T) {
	ctx := context.Background()
	dbPath := setupFileBasedTestDB(t)

Replacement in tools/import/import_files_test.go at line 83 [5.27703]

B:BD[5.29919] → [5.29919:30113]

	t.Run("duplicate handling - skip file with existing hash", func(t *testing.T) {
		dbPath := setupFileBasedTestDB(t)
		// Don't keep database open - ImportAudioFiles manages its own connections

[5.29919]

[5.30113]

	// Create temp folder with a WAV file
	tmpDir := t.TempDir()
	wavPath := filepath.Join(tmpDir, "test_recording.wav")
	hash := createTestWAV(t, wavPath)

Replacement in tools/import/import_files_test.go at line 88 [5.27703]

B:BD[5.30114] → [5.30114:30271]

		// Create temp folder with a WAV file
		tmpDir := t.TempDir()
		wavPath := filepath.Join(tmpDir, "test_recording.wav")
		hash := createTestWAV(t, wavPath)

[5.30114]

[5.30271]

	// First import
	_, err := ImportAudioFiles(ctx, ImportAudioFilesInput{
		DBPath:     dbPath,
		FolderPath: tmpDir,
		DatasetID:  "dstest000001",
		LocationID: "loctest00001",
		ClusterID:  "cltest000001",
		Recursive:  new(true),
	})
	if err != nil {
		t.Fatalf("first import failed: %v", err)
	}

Replacement in tools/import/import_files_test.go at line 101 [5.27703]

B:BD[5.30272] → [5.30272:30583]

		// First import
		_, err := ImportAudioFiles(ctx, ImportAudioFilesInput{
			DBPath:     dbPath,
			FolderPath: tmpDir,
			DatasetID:  "dstest000001",
			LocationID: "loctest00001",
			ClusterID:  "cltest000001",
			Recursive:  new(true),
		})
		if err != nil {
			t.Fatalf("first import failed: %v", err)
		}

[5.30272]

[5.30583]

	// Second import of same file (should be skipped as duplicate)
	output, err := ImportAudioFiles(ctx, ImportAudioFilesInput{
		DBPath:     dbPath,
		FolderPath: tmpDir,
		DatasetID:  "dstest000001",
		LocationID: "loctest00001",
		ClusterID:  "cltest000001",
		Recursive:  new(true),
	})
	if err != nil {
		t.Fatalf("second import failed: %v", err)
	}

Replacement in tools/import/import_files_test.go at line 114 [5.27703]

B:BD[5.30584] → [5.30584:30948]

		// Second import of same file (should be skipped as duplicate)
		output, err := ImportAudioFiles(ctx, ImportAudioFilesInput{
			DBPath:     dbPath,
			FolderPath: tmpDir,
			DatasetID:  "dstest000001",
			LocationID: "loctest00001",
			ClusterID:  "cltest000001",
			Recursive:  new(true),
		})
		if err != nil {
			t.Fatalf("second import failed: %v", err)
		}

[5.30584]

[5.30948]

	// Verify output
	if output.Summary.TotalFiles != 1 {
		t.Errorf("expected 1 total file, got %d", output.Summary.TotalFiles)
	}
	if output.Summary.ImportedFiles != 0 {
		t.Errorf("expected 0 imported files (duplicate), got %d", output.Summary.ImportedFiles)
	}
	if output.Summary.SkippedFiles != 1 {
		t.Errorf("expected 1 skipped file (duplicate), got %d", output.Summary.SkippedFiles)
	}

Replacement in tools/import/import_files_test.go at line 125 [5.27703]

B:BD[5.30949] → [5.30949:31350]

		// Verify output
		if output.Summary.TotalFiles != 1 {
			t.Errorf("expected 1 total file, got %d", output.Summary.TotalFiles)
		}
		if output.Summary.ImportedFiles != 0 {
			t.Errorf("expected 0 imported files (duplicate), got %d", output.Summary.ImportedFiles)
		}
		if output.Summary.SkippedFiles != 1 {
			t.Errorf("expected 1 skipped file (duplicate), got %d", output.Summary.SkippedFiles)
		}

[5.30949]

[5.31350]

	// Verify only one file in database (not duplicated) - open new connection
	database, err := sql.Open("duckdb", dbPath)
	if err != nil {
		t.Fatalf("failed to open database for verification: %v", err)
	}
	defer database.Close()

Replacement in tools/import/import_files_test.go at line 132 [5.27703]

B:BD[5.31351] → [5.31351:31586]

		// Verify only one file in database (not duplicated) - open new connection
		database, err := sql.Open("duckdb", dbPath)
		if err != nil {
			t.Fatalf("failed to open database for verification: %v", err)
		}
		defer database.Close()

[5.31351]

[5.31586]

	var fileCount int
	err = database.QueryRow("SELECT COUNT(*) FROM file WHERE xxh64_hash = ? AND active = true", hash).Scan(&fileCount)
	if err != nil {
		t.Fatalf("failed to query file: %v", err)
	}
	if fileCount != 1 {
		t.Errorf("expected 1 file in database (not duplicated), got %d", fileCount)
	}
}

Replacement in tools/import/import_files_test.go at line 142 [5.27703]

B:BD[5.31587] → [5.31587:31900]

		var fileCount int
		err = database.QueryRow("SELECT COUNT(*) FROM file WHERE xxh64_hash = ? AND active = true", hash).Scan(&fileCount)
		if err != nil {
			t.Fatalf("failed to query file: %v", err)
		}
		if fileCount != 1 {
			t.Errorf("expected 1 file in database (not duplicated), got %d", fileCount)
		}
	})

[5.31587]

[5.31900]

func TestImportAudioFiles_ErrorCases(t *testing.T) {
	ctx := context.Background()

Replacement in lint_test.go at line 48 [11.776165]

B:BD[10.158] → [6.146:224]

	cmd := exec.Command("gocyclo", "-over", "12", "-ignore", "_test\\.go$", ".")

[10.158]

[10.210]

	cmd := exec.Command("gocyclo", "-over", "11", "-ignore", "_test\\.go$", ".")

Replacement in lint_test.go at line 52 [11.776165]

B:BD[10.276] → [12.15937:15996]

		t.Errorf("cyclometric complexity is above 12:\n%s", out)

[10.276]

[10.335]

		t.Errorf("cyclometric complexity is above 11:\n%s", out)

Replacement in db/schema.go at line 227 [11.1000207]

B:BD[11.1005872] → [13.9108:9322]

// topologicalSort orders tables so dependencies come first (Kahn's algorithm).
// Tables in cycles are appended at the end.
func topologicalSort(tables map[string]bool, dependsOnMe map[string][]string) []string {

[11.1005872]

[13.9322]

// countDependencies counts FK dependencies for each table.
func countDependencies(tables map[string]bool, dependsOnMe map[string][]string) map[string]int {

Insertion in db/schema.go at line 238 [11.1000207]
[11.1006133]
[11.1006133]
```
	return fkCount
}
```

Insertion in db/schema.go at line 241 [11.1000207]

[11.1006134]

[11.1006230]

// buildInitialQueue builds the initial queue of tables with no dependencies.
func buildInitialQueue(tables map[string]bool, fkCount map[string]int) []string {

Insertion in db/schema.go at line 247 [11.1000207]

[11.1006338]

		}
	}
	return queue
}
// appendCyclicTables adds tables that are part of cycles to the result.
func appendCyclicTables(result []string, tables map[string]bool) []string {
	if len(result) == len(tables) {
		return result
	}
	for table := range tables {
		if !slices.Contains(result, table) {
			result = append(result, table)

Insertion in db/schema.go at line 262 [11.1000207]

[11.1006345]

	return result
}
// topologicalSort orders tables so dependencies come first (Kahn's algorithm).
// Tables in cycles are appended at the end.
func topologicalSort(tables map[string]bool, dependsOnMe map[string][]string) []string {
	fkCount := countDependencies(tables, dependsOnMe)
	queue := buildInitialQueue(tables, fkCount)

Replacement in db/schema.go at line 285 [11.1000207]
B:BD[11.1006735] → [13.9369:9412]
∅:D[13.9412] → [11.1006793:1006826]
B:BD[11.1006793] → [11.1006793:1006826]
B:BD[11.1006869] → [11.1006869:1006899]
B:BD[11.1006899] → [13.9413:9453]
∅:D[13.9453] → [11.1006957:1007004]
B:BD[11.1006957] → [11.1006957:1007004]
B:BD[11.1007004] → [13.9454:9469]
```
	// Handle cycles: append remaining tables
	if len(result) != len(tables) {
		for table := range tables {
			if !slices.Contains(result, table) {
				result = append(result, table)
			}
		}
	}
	return result
```
[11.1006735]
[11.1007025]
```
	return appendCyclicTables(result, tables)
```
Replacement in cmd/calls_push_certainty.go at line 52 [11.1103981]
B:BD[11.1106231] → [11.1106231:1106265]
B:BD[11.1106265] → [14.3493:3539]
∅:D[14.3539] → [11.1106408:1106425]
∅:D[15.24861] → [11.1106408:1106425]
B:BD[11.1106408] → [11.1106408:1106425]
B:BD[11.1106425] → [14.3540:3582]
∅:D[14.3582] → [11.1106564:1106583]
∅:D[15.24902] → [11.1106564:1106583]
B:BD[11.1106564] → [11.1106564:1106583]
B:BD[11.1106583] → [14.3583:3629]
∅:D[14.3629] → [11.1106726:1106746]
∅:D[15.24945] → [11.1106726:1106746]
B:BD[11.1106726] → [11.1106726:1106746]
B:BD[11.1106746] → [14.3630:3678]
∅:D[14.3678] → [11.1106891:1106909]
∅:D[15.24989] → [11.1106891:1106909]
B:BD[11.1106891] → [11.1106891:1106909]
B:BD[11.1106909] → [15.24990:25008]
∅:D[15.25008] → [11.1106925:1106932]
B:BD[11.1106925] → [11.1106925:1106932]
B:BD[11.1106933] → [11.1106933:1106949]
B:BD[11.1106949] → [15.25009:25025]
∅:D[15.25025] → [11.1106963:1106970]
B:BD[11.1106963] → [11.1106963:1106970]
B:BD[11.1106970] → [16.1037:1180]
B:BD[16.1180] → [14.3679:3729]
∅:D[16.1224] → [11.1107759:1107825]
∅:D[14.3729] → [11.1107759:1107825]
∅:D[15.25188] → [11.1107759:1107825]
B:BD[11.1107759] → [11.1107759:1107825]
B:BD[11.1107826] → [11.1107826:1107837]
```
		switch arg {
		case "--folder":
			f.folder = mustValue(args, &i, "--folder")
		case "--file":
			f.file = mustValue(args, &i, "--file")
		case "--filter":
			f.filter = mustValue(args, &i, "--filter")
		case "--species":
			f.species = mustValue(args, &i, "--species")
		case "--night":
			f.night = true
			i++
		case "--day":
			f.day = true
			i++
		case "--location":
			if f.location != "" {
				fmt.Fprintf(os.Stderr, "Error: --location can only be specified once\n")
				os.Exit(1)
			}
			f.location = mustValue(args, &i, "--location")
		case "--help", "-h":
			printPushCertaintyUsage()
			os.Exit(0)
		default:
```
[11.1106231]
[11.1107899]
```
		if !parsePushCertaintyFlag(arg, args, &i, &f) {
```

Insertion in cmd/calls_push_certainty.go at line 59 [11.1103981]

[15.25199]

[15.25483]

}
// parsePushCertaintyFlag handles a single flag. Returns false if unknown flag.
func parsePushCertaintyFlag(arg string, args []string, i *int, f *pushCertaintyFlags) bool {
	switch arg {
	case "--folder":
		f.folder = mustValue(args, i, "--folder")
	case "--file":
		f.file = mustValue(args, i, "--file")
	case "--filter":
		f.filter = mustValue(args, i, "--filter")
	case "--species":
		f.species = mustValue(args, i, "--species")
	case "--night":
		f.night = true
		*i++
	case "--day":
		f.day = true
		*i++
	case "--location":
		if f.location != "" {
			fmt.Fprintf(os.Stderr, "Error: --location can only be specified once\n")
			os.Exit(1)
		}
		f.location = mustValue(args, i, "--location")
	case "--help", "-h":
		printPushCertaintyUsage()
		os.Exit(0)
	default:
		return false
	}
	return true

Insertion in CHANGELOG.md at line 4 [11.1197933]

[11.1198010]

[3.218]


## [2026-05-19] tools/calls and tools/import refactoring complete — all 5 phases done
Refactored `tools/calls/` and `tools/import/` to improve code quality, test coverage, and interface consistency.
### Phase 0: Tests for tools/import Critical Paths
- Created `tools/import/test_helpers.go` with shared test utilities
- Added tests for `ImportAudioFiles`, `ImportUnstructured`, `ImportSegments`, `writeIDsToDataFiles`, `BulkFileImport`
- **Coverage increased from 20.7% to 71.9%**
### Phase 1: Reduce Cyclomatic Complexity
- Extracted `resolveLabelIDs`, `insertLabel`, `insertLabelMetadata` from `importSingleLabel`
- Extracted `detectBirdaColumns`, `validateBirdaColumns` from `parseBirdaCSVHeader`
- Extracted `validateAndParseShowImagesInput`, `resolveImageSize`, `resolveGraphicsProtocol`, `displaySegmentSpectrograms` from `CallsShowImages`
- Fixed `scanWavFiles`, `CallsRemove`, `findMatchingLabels` complexity issues
- **All functions now under complexity 10**
### Phase 2: Split import_segments.go
- Created `import_segments_prepare.go` (429 lines) — validation, scanning, ID lookup
- Created `import_segments_db.go` (422 lines) — DB write, writeback
- Reduced `import_segments.go` to 155 lines — orchestrator + types
### Phase 3: Fix *sql.DB Usage
- **3A (tools/):** Changed `validateClusterActive`, `validateClusterCyclicPattern`, `executeSQLQuery` to use `db.Querier`
- **3A (tools/export.go):** Defined local `writer` interface; replaced `sql.Open` with `db.OpenWriteableDB`
- **3A (db/schema.go):** Changed `GetFKOrder`, `buildFKDependencyGraph`, `collectAllTables` to `db.Querier`
- **3B (tools/import/):** Changed all bulk functions to accept `Mutator` interface
- Updated `ImportSegments`, `ImportFile` to use `WithReadDB`/`WithWriteTx` patterns
- Raw `*sql.DB` now only appears in callback signatures and type assertions
### Phase 4: Move Classify TUI-Adjacent Types to Dedicated Files
- Created `classify_bindings.go` (123 lines) — `KeyBinding`, `BindingResult`, binding methods
- Created `classify_format.go` (32 lines) — `FormatLabels`
- Created `classify_io.go` (106 lines) — `LoadFilteredSegment`, `SaveClip`, `PlaySegmentAtSpeed`
- Created `classify_bookmarks.go` (135 lines) — bookmark navigation methods
- Created `classify_labels.go` (87 lines) — label manipulation methods
- Added documentation for TUI-only fields in `ClassifyConfig`
- **`calls_classify.go` reduced from 802 to 375 lines**
### Phase 5: Consolidate Shared Types into from_common.go
- Moved `ClusteredCall`, `DirCache`, `ParseFilterFromFilename`, `clusterStartTimes`, `clusterDetections`, `predFileSpeciesKey` to `calls_from_common.go`
- **`calls_from_preds.go` reduced from 717 to 546 lines (24% reduction)**
- **`calls_from_common.go` grew from 287 to 460 lines**

Insertion in CHANGELOG.md at line 48 [11.1197933]

[3.219]

### Summary
| Metric | Before | After |
|--------|--------|-------|
| tools/import test coverage | 20.7% | 71.9% |
| Max cyclomatic complexity | 12+ | <10 |
| import_segments.go lines | 944 | 155 |
| calls_classify.go lines | 802 | 375 |
| calls_from_preds.go lines | 717 | 546 |

Replacement in .golangci.yml at line 14 [18.217]
B:BD[17.22132] → [2.200:225]
```
      max-complexity: 12
```
[17.22132]
[17.22157]
```
      max-complexity: 11
```