quietlight/skraak_mcp - Change SB4FZEB6ZLUHQNM3M76OGNNJY6THOF55S6JO6Q7IGXWE7OA7INFAC

added --certainty flags to folder level cmds

Created by quietlight on April 2, 2026

SB4FZEB6ZLUHQNM3M76OGNNJY6THOF55S6JO6Q7IGXWE7OA7INFAC

Dependencies

In channels

main

Change contents

Replacement in utils/data_file_test.go at line 402 [5.1]

B:BD[4.162] → [4.162:284]

			{Species: "Kiwi", Filter: "model-1.0", CallType: "Duet"},
			{Species: "Morepork", Filter: "model-2.0", CallType: ""},

[4.162]

[4.284]

			{Species: "Kiwi", Filter: "model-1.0", CallType: "Duet", Certainty: 70},
			{Species: "Morepork", Filter: "model-2.0", CallType: "", Certainty: 100},

Insertion in utils/data_file_test.go at line 412 [5.1]
[4.386]
[4.386]
```
		certainty int
```

Replacement in utils/data_file_test.go at line 415 [5.1]

B:BD[4.406] → [4.406:1008]

		{"no filters", "", "", "", true},
		{"filter only match", "model-1.0", "", "", true},
		{"filter only no match", "model-3.0", "", "", false},
		{"species only match", "", "Kiwi", "", true},
		{"species only no match", "", "Tomtit", "", false},
		{"calltype only match", "", "", "Duet", true},
		{"calltype only no match", "", "", "Male", false},
		{"filter+species match", "model-1.0", "Kiwi", "", true},
		{"filter+species+calltype match", "model-1.0", "Kiwi", "Duet", true},
		{"filter match species miss", "model-1.0", "Morepork", "", false},
		{"all miss", "model-3.0", "Tomtit", "Male", false},

[4.406]

[4.1008]

		{"no filters", "", "", "", -1, true},
		{"filter only match", "model-1.0", "", "", -1, true},
		{"filter only no match", "model-3.0", "", "", -1, false},
		{"species only match", "", "Kiwi", "", -1, true},
		{"species only no match", "", "Tomtit", "", -1, false},
		{"calltype only match", "", "", "Duet", -1, true},
		{"calltype only no match", "", "", "Male", -1, false},
		{"certainty match", "", "", "", 70, true},
		{"certainty no match", "", "", "", 80, false},
		{"certainty 100 match", "", "", "", 100, true},
		{"filter+species match", "model-1.0", "Kiwi", "", -1, true},
		{"filter+species+calltype match", "model-1.0", "Kiwi", "Duet", -1, true},
		{"filter+species+calltype+certainty match", "model-1.0", "Kiwi", "Duet", 70, true},
		{"filter+species+calltype certainty miss", "model-1.0", "Kiwi", "Duet", 100, false},
		{"filter match species miss", "model-1.0", "Morepork", "", -1, false},
		{"all miss", "model-3.0", "Tomtit", "Male", -1, false},

Replacement in utils/data_file_test.go at line 435 [5.1]

B:BD[4.1078] → [4.1078:1150]

			got := seg.SegmentMatchesFilters(tt.filter, tt.species, tt.callType)

[4.1078]

[4.1150]

			got := seg.SegmentMatchesFilters(tt.filter, tt.species, tt.callType, tt.certainty)

Replacement in utils/data_file_test.go at line 437 [5.1]

B:BD[4.1173] → [4.1173:1292]

				t.Errorf("SegmentMatchesFilters(%q, %q, %q) = %v, want %v",
					tt.filter, tt.species, tt.callType, got, tt.want)

[4.1173]

[4.1292]

				t.Errorf("SegmentMatchesFilters(%q, %q, %q, %d) = %v, want %v",
					tt.filter, tt.species, tt.callType, tt.certainty, got, tt.want)

Replacement in utils/data_file.go at line 292 [5.3760]

B:BD[4.2032] → [4.2032:2244]

// All non-empty parameters must match for a label to be considered a match.
func (s *Segment) SegmentMatchesFilters(filter, species, callType string) bool {
	if filter == "" && species == "" && callType == "" {

[4.2032]

[4.2244]

// All non-empty/non-negative parameters must match for a label to be considered a match.
// Use certainty=-1 to indicate no certainty filtering (since 0 is a valid certainty value).
func (s *Segment) SegmentMatchesFilters(filter, species, callType string, certainty int) bool {
	if filter == "" && species == "" && callType == "" && certainty < 0 {

Insertion in utils/data_file.go at line 309 [5.3760]

[4.2516]

		if certainty >= 0 && label.Certainty != certainty {
			continue
		}

Replacement in tools/calls_clip.go at line 16 [6.2441]

B:BD[6.2618] → [6.2618:3161]

B:BD[6.3161] → [3.70:267]

	File    string `json:"file" jsonschema:"Path to .data file (required if no folder)"`
	Folder  string `json:"folder" jsonschema:"Path to folder containing .data files (required if no file)"`
	Output  string `json:"output" jsonschema:"required,Output folder for generated clips"`
	Prefix  string `json:"prefix" jsonschema:"required,Prefix for output filenames"`
	Filter  string `json:"filter" jsonschema:"Filter by ML model name"`
	Species string `json:"species" jsonschema:"Filter by species, optionally with calltype (e.g. Kiwi, Kiwi+Duet)"`
	Size    int    `json:"size" jsonschema:"Spectrogram image size in pixels (224-896, default 224)"`
	Color   bool   `json:"color" jsonschema:"Apply L4 colormap to spectrogram (default: grayscale)"`

[6.2618]

[6.3161]

	File      string `json:"file" jsonschema:"Path to .data file (required if no folder)"`
	Folder    string `json:"folder" jsonschema:"Path to folder containing .data files (required if no file)"`
	Output    string `json:"output" jsonschema:"required,Output folder for generated clips"`
	Prefix    string `json:"prefix" jsonschema:"required,Prefix for output filenames"`
	Filter    string `json:"filter" jsonschema:"Filter by ML model name"`
	Species   string `json:"species" jsonschema:"Filter by species, optionally with calltype (e.g. Kiwi, Kiwi+Duet)"`
	Certainty int    `json:"certainty" jsonschema:"Filter by certainty value (0-100, -1 for no filter)"`
	Size      int    `json:"size" jsonschema:"Spectrogram image size in pixels (224-896, default 224)"`
	Color     bool   `json:"color" jsonschema:"Apply L4 colormap to spectrogram (default: grayscale)"`

Replacement in tools/calls_clip.go at line 86 [6.2441]

B:BD[6.5224] → [3.351:477]

		clips, errs := processFile(dataPath, input.Output, input.Prefix, input.Filter, speciesName, callType, imgSize, input.Color)

[6.5224]

[6.5328]

		clips, errs := processFile(dataPath, input.Output, input.Prefix, input.Filter, speciesName, callType, input.Certainty, imgSize, input.Color)

Replacement in tools/calls_clip.go at line 99 [6.2441]

B:BD[6.5658] → [3.478:610]

func processFile(dataPath, outputDir, prefix, filter, speciesName, callType string, imgSize int, color bool) ([]string, []string) {

[6.5658]

[6.5765]

func processFile(dataPath, outputDir, prefix, filter, speciesName, callType string, certainty, imgSize int, color bool) ([]string, []string) {

Replacement in tools/calls_clip.go at line 118 [6.2441]

B:BD[6.6242] → [4.3010:3074]

		if seg.SegmentMatchesFilters(filter, speciesName, callType) {

[6.6242]

[6.6307]

		if seg.SegmentMatchesFilters(filter, speciesName, callType, certainty) {

Replacement in tools/calls_classify_test.go at line 76 [5.15273]

B:BD[5.17363] → [5.17363:17436]

			Filter:   "test-filter",
			Reviewer: "David",
			Bindings: bindings,

[5.17363]

[5.17436]

			Filter:    "test-filter",
			Reviewer:  "David",
			Bindings:  bindings,
			Certainty: -1,

Replacement in tools/calls_classify_test.go at line 147 [5.15273]

B:BD[5.20130] → [5.20130:20203]

			Filter:   "test-filter",
			Reviewer: "David",
			Bindings: bindings,

[5.20130]

[5.20203]

			Filter:    "test-filter",
			Reviewer:  "David",
			Bindings:  bindings,
			Certainty: -1,

Replacement in tools/calls_classify_load_test.go at line 32 [2.1]
B:BD[2.979] → [2.979:1023]
```
	config1 := ClassifyConfig{Folder: tempDir}
```
[2.979]
[2.1023]
```
	config1 := ClassifyConfig{Folder: tempDir, Certainty: -1}
```

Replacement in tools/calls_classify_load_test.go at line 45 [2.1]

B:BD[2.1397] → [2.1397:1458]

	config2 := ClassifyConfig{Folder: tempDir, Species: "Kiwi"}

[2.1397]

[2.1458]

	config2 := ClassifyConfig{Folder: tempDir, Species: "Kiwi", Certainty: -1}

Replacement in tools/calls_classify_load_test.go at line 58 [2.1]

B:BD[2.1833] → [2.1833:1896]

	config3 := ClassifyConfig{Folder: tempDir, Species: "Tomtit"}

[2.1833]

[2.1896]

	config3 := ClassifyConfig{Folder: tempDir, Species: "Tomtit", Certainty: -1}

Replacement in tools/calls_classify_load_test.go at line 72 [2.1]

B:BD[2.2343] → [2.2343:2411]

	config4 := ClassifyConfig{Folder: tempDir, Species: "NonExistent"}

[2.2343]

[2.2411]

	config4 := ClassifyConfig{Folder: tempDir, Species: "NonExistent", Certainty: -1}

Replacement in tools/calls_classify_load_test.go at line 101 [2.1]

B:BD[2.3397] → [2.3397:3457]

	config := ClassifyConfig{Folder: tempDir, Species: "Kiwi"}

[2.3397]

[2.3457]

	config := ClassifyConfig{Folder: tempDir, Species: "Kiwi", Certainty: -1}

Replacement in tools/calls_classify_load_test.go at line 138 [2.1]

B:BD[2.4638] → [2.4638:4698]

	config := ClassifyConfig{Folder: tempDir, Species: "Kiwi"}

[2.4638]

[2.4698]

	config := ClassifyConfig{Folder: tempDir, Species: "Kiwi", Certainty: -1}

Replacement in tools/calls_classify_filter_test.go at line 46 [2.5379]
B:BD[2.6212] → [2.6212:6243]
```
		Config:    ClassifyConfig{},
```
[2.6212]
[2.6243]
```
		Config:    ClassifyConfig{Certainty: -1},
```
Replacement in tools/calls_classify_filter_test.go at line 55 [2.5379]
B:BD[2.6499] → [2.6499:6545]
```
		Config:    ClassifyConfig{Species: "Kiwi"},
```
[2.6499]
[2.6545]
```
		Config:    ClassifyConfig{Species: "Kiwi", Certainty: -1},
```
Replacement in tools/calls_classify_filter_test.go at line 64 [2.5379]
B:BD[2.6807] → [2.6807:6855]
```
		Config:    ClassifyConfig{Species: "Tomtit"},
```
[2.6807]
[2.6855]
```
		Config:    ClassifyConfig{Species: "Tomtit", Certainty: -1},
```

Replacement in tools/calls_classify_filter_test.go at line 73 [2.5379]

B:BD[2.7117] → [2.7117:7167]

		Config:    ClassifyConfig{Filter: "model-1.0"},

[2.7117]

[2.7167]

		Config:    ClassifyConfig{Filter: "model-1.0", Certainty: -1},

Replacement in tools/calls_classify_filter_test.go at line 82 [2.5379]

B:BD[2.7414] → [2.7414:7467]

		Config:    ClassifyConfig{Species: "NonExistent"},

[2.7414]

[2.7467]

		Config:    ClassifyConfig{Species: "NonExistent", Certainty: -1},

Replacement in tools/calls_classify_filter_test.go at line 110 [2.5379]

B:BD[2.8083] → [2.8083:8150]

		Config:    ClassifyConfig{Filter: "model-1.0", Species: "Kiwi"},

[2.8083]

[2.8150]

		Config:    ClassifyConfig{Filter: "model-1.0", Species: "Kiwi", Certainty: -1},

Replacement in tools/calls_classify_filter_test.go at line 156 [2.5379]
B:BD[2.9146] → [2.9146:9193]
```
		Config:     ClassifyConfig{Species: "Kiwi"},
```
[2.9146]
[2.9193]
```
		Config:     ClassifyConfig{Species: "Kiwi", Certainty: -1},
```

Insertion in tools/calls_classify_filter_test.go at line 164 [2.5379]

[2.9422]

	}
}
func TestCertaintyFiltering(t *testing.T) {
	// Create test data files with different certainty levels
	df := &utils.DataFile{
		FilePath: "/test/file1.data",
		Segments: []*utils.Segment{
			{
				StartTime: 0,
				EndTime:   10,
				Labels: []*utils.Label{
					{Species: "Kiwi", Filter: "model-1.0", Certainty: 70},
				},
			},
			{
				StartTime: 10,
				EndTime:   20,
				Labels: []*utils.Label{
					{Species: "Kiwi", Filter: "model-1.0", Certainty: 100},
				},
			},
			{
				StartTime: 20,
				EndTime:   30,
				Labels: []*utils.Label{
					{Species: "Tomtit", Filter: "model-1.0", Certainty: 70},
				},
			},
		},
	}
	// Test 1: Filter by certainty 70 - should get 2 segments
	state1 := &ClassifyState{
		Config:    ClassifyConfig{Certainty: 70},
		DataFiles: []*utils.DataFile{df},
	}
	if got := state1.TotalSegments(); got != 2 {
		t.Errorf("Certainty=70: expected 2 segments, got %d", got)
	}
	// Test 2: Filter by certainty 100 - should get 1 segment
	state2 := &ClassifyState{
		Config:    ClassifyConfig{Certainty: 100},
		DataFiles: []*utils.DataFile{df},
	}
	if got := state2.TotalSegments(); got != 1 {
		t.Errorf("Certainty=100: expected 1 segment, got %d", got)
	}
	// Test 3: Filter by certainty 0 - should get 0 segments
	state3 := &ClassifyState{
		Config:    ClassifyConfig{Certainty: 0},
		DataFiles: []*utils.DataFile{df},
	}
	if got := state3.TotalSegments(); got != 0 {
		t.Errorf("Certainty=0: expected 0 segments, got %d", got)
	}
	// Test 4: Combined species + certainty
	state4 := &ClassifyState{
		Config:    ClassifyConfig{Species: "Kiwi", Certainty: 70},
		DataFiles: []*utils.DataFile{df},

Insertion in tools/calls_classify_filter_test.go at line 228 [2.5379]

[2.9425]

	if got := state4.TotalSegments(); got != 1 {
		t.Errorf("Species=Kiwi + Certainty=70: expected 1 segment, got %d", got)
	}

Insertion in tools/calls_classify.go at line 26 [5.20592]

[7.184]

[8.819]

	Certainty int    // scope to this certainty value, -1 = no filter (optional)

Replacement in tools/calls_classify.go at line 149 [5.20592]

B:BD[5.22997] → [7.185:281]

// getFilteredSegments returns segments matching the active filters (filter, species, calltype)

[5.22997]

[5.23057]

// getFilteredSegments returns segments matching the active filters (filter, species, calltype, certainty)

Replacement in tools/calls_classify.go at line 151 [5.20592]

B:BD[5.23140] → [7.282:336]

	if s.Config.Filter == "" && s.Config.Species == "" {

[5.23140]

[5.23168]

	if s.Config.Filter == "" && s.Config.Species == "" && s.Config.Certainty < 0 {

Replacement in tools/calls_classify.go at line 166 [5.20592]

B:BD[7.542] → [4.3079:3167]

	return seg.SegmentMatchesFilters(s.Config.Filter, s.Config.Species, s.Config.CallType)

[7.542]

[7.858]

	return seg.SegmentMatchesFilters(s.Config.Filter, s.Config.Species, s.Config.CallType, s.Config.Certainty)

Insertion in cmd/calls_clip.go at line 23 [6.10182]

[6.11088]

[3.1342]

	fmt.Fprintf(os.Stderr, "  --certainty <int>  Filter by certainty value (0-100, optional)\n")

Replacement in cmd/calls_clip.go at line 43 [6.10182]
B:BD[6.12205] → [3.1839:1853]
```
	var size int
```
[6.12205]
[3.1853]
```
	var size, certainty int
```
Insertion in cmd/calls_clip.go at line 45 [6.10182]
[3.1869]
[6.12205]
```
	// Default to -1 (no certainty filter)
	certainty = -1
```

Insertion in cmd/calls_clip.go at line 109 [6.10182]

[6.13480]

[3.1870]

			i += 2
		case "--certainty":
			if i+1 >= len(args) {
				fmt.Fprintf(os.Stderr, "Error: --certainty requires a value\n")
				os.Exit(1)
			}
			v, err := strconv.Atoi(args[i+1])
			if err != nil {
				fmt.Fprintf(os.Stderr, "Error: --certainty must be an integer\n")
				os.Exit(1)
			}
			if v < 0 || v > 100 {
				fmt.Fprintf(os.Stderr, "Error: --certainty must be between 0 and 100\n")
				os.Exit(1)
			}
			certainty = v

Replacement in cmd/calls_clip.go at line 179 [6.10182]

B:BD[6.14189] → [6.14189:14302]

B:BD[6.14302] → [3.2203:2238]

		File:    file,
		Folder:  folder,
		Output:  output,
		Prefix:  prefix,
		Filter:  filter,
		Species: species,
		Size:    size,
		Color:   color,

[6.14189]

[6.14302]

		File:      file,
		Folder:    folder,
		Output:    output,
		Prefix:    prefix,
		Filter:    filter,
		Species:   species,
		Certainty: certainty,
		Size:      size,
		Color:     color,

Insertion in cmd/calls_classify.go at line 28 [5.28389]

[7.1039]

[9.1063]

	fmt.Fprintf(os.Stderr, "  --certainty <int>     Scope to certainty value (0-100, optional)\n")

Replacement in cmd/calls_classify.go at line 52 [5.28389]
∅:D[10.2845] → [8.1013:1030]
∅:D[11.9804] → [8.1013:1030]
B:BD[5.28699] → [8.1013:1030]
```
	var imgDims int
```
[10.2845]
[5.28699]
```
	var imgDims, certainty int
```
Insertion in cmd/calls_classify.go at line 55 [5.28389]
[5.28733]
[5.28733]
```
	// Default to -1 (no certainty filter)
	certainty = -1
```
Replacement in cmd/calls_classify.go at line 92 [5.28389]
B:BD[7.1586] → [7.1586:1606]
```
		case "--species":
```
[7.1586]
[7.1606]
```
	case "--species":
```

Insertion in cmd/calls_classify.go at line 102 [5.28389]

[7.1858]

[5.29284]

			i += 2
		case "--certainty":
			if i+1 >= len(args) {
				fmt.Fprintf(os.Stderr, "Error: --certainty requires a value\n")
				os.Exit(1)
			}
			v, err := strconv.Atoi(args[i+1])
			if err != nil {
				fmt.Fprintf(os.Stderr, "Error: --certainty must be an integer\n")
				os.Exit(1)
			}
			if v < 0 || v > 100 {
				fmt.Fprintf(os.Stderr, "Error: --certainty must be between 0 and 100\n")
				os.Exit(1)
			}
			certainty = v

Insertion in cmd/calls_classify.go at line 198 [5.28389]
[7.2165]
[8.1397]
```
		Certainty: certainty,
```