quietlight/skraak_mcp - Change NLDETC7D5WRGA4U6FIGBV2KKY4L2TLWOTH3HU4ZCU2SUV63EGAXQC

deleting dead code, first pass

Created by quietlight on April 19, 2026

NLDETC7D5WRGA4U6FIGBV2KKY4L2TLWOTH3HU4ZCU2SUV63EGAXQC

Dependencies

In channels

main

Change contents

Deletion in utils/validation.go at line 190 [6.7984]

B:BD[6.13748] → [6.13748:14803]

}
// 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

Deletion in utils/validation.go at line 255 [6.7984]

B:BD[5.736] → [5.736:1459]

// ValidateClusterBelongsToLocation checks that a cluster belongs to a specific location
// Returns error if cluster doesn't exist or belongs to a different location
func ValidateClusterBelongsToLocation(db *sql.DB, clusterID, locationID string) error {
	var clusterLocationID string
	err := db.QueryRow("SELECT location_id FROM cluster WHERE id = ? AND active = true", clusterID).Scan(&clusterLocationID)
	if err == sql.ErrNoRows {
		return fmt.Errorf("cluster not found or inactive: %s", clusterID)
	}
	if err != nil {
		return fmt.Errorf("failed to query cluster: %w", err)
	}
	if clusterLocationID != locationID {
		return fmt.Errorf("cluster %s does not belong to location %s", clusterID, locationID)
	}
	return nil
}

Deletion in tools/export.go at line 357 [7.1]

B:BD[7.15727] → [7.15727:15861]

B:BD[7.15861] → [3.2496:2567]

∅:D[3.2567] → [8.1008:1113]

B:BD[8.1008] → [8.1008:1113]

B:BD[8.1113] → [3.2568:2654]

∅:D[8.1207] → [7.17102:17105]

∅:D[3.2654] → [7.17102:17105]

B:BD[7.17102] → [7.17102:17105]

// buildCountReferencedQuery builds a count query for referenced tables
func buildCountReferencedQuery(tr TableRelationship) string {
	// Only filter table is referenced via label -> segment -> dataset_id
	return `SELECT COUNT(DISTINCT filter.id) FROM filter 
		INNER JOIN label ON filter.id = label.filter_id
		INNER JOIN segment ON label.segment_id = segment.id
		WHERE segment.dataset_id = ?`
}

Deletion in tools/calls_from_preds.go at line 529 [9.1]

B:BD[4.1096] → [4.1096:1098]

∅:D[4.1098] → [10.4700:4701]

B:BD[10.4700] → [10.4700:4701]

B:BD[10.4701] → [4.1099:1426]

}
// buildAviaNZDataFile creates an AviaNZ .data structure from calls (for new files only)
func buildAviaNZDataFile(calls []ClusteredCall, filter string, duration float64, sampleRate int) []any {
	meta, segments := buildAviaNZMetaAndSegments(calls, filter, duration, sampleRate)
	return buildDataFileFromSegments(meta, segments)

Deletion in db/types.go at line 156 [11.161605]

B:BD[11.167272] → [11.167272:168788]

// MarshalJSON implements custom JSON marshaling for File
// Formats timestamps as RFC3339
func (f File) MarshalJSON() ([]byte, error) {
	return json.Marshal(&struct {
		ID              string   `json:"id"`
		FileName        string   `json:"file_name"`
		Path            *string  `json:"path"`
		XXH64Hash       string   `json:"xxh64_hash"`
		LocationID      string   `json:"location_id"`
		TimestampLocal  string   `json:"timestamp_local"`
		ClusterID       *string  `json:"cluster_id"`
		Duration        float64  `json:"duration"`
		SampleRate      int      `json:"sample_rate"`
		Description     *string  `json:"description"`
		MaybeSolarNight *bool    `json:"maybe_solar_night"`
		MaybeCivilNight *bool    `json:"maybe_civil_night"`
		MoonPhase       *float64 `json:"moon_phase"`
		CreatedAt       string   `json:"created_at"`
		LastModified    string   `json:"last_modified"`
		Active          bool     `json:"active"`
	}{
		ID:              f.ID,
		FileName:        f.FileName,
		Path:            f.Path,
		XXH64Hash:       f.XXH64Hash,
		LocationID:      f.LocationID,
		TimestampLocal:  f.TimestampLocal.Format(time.RFC3339),
		ClusterID:       f.ClusterID,
		Duration:        f.Duration,
		SampleRate:      f.SampleRate,
		Description:     f.Description,
		MaybeSolarNight: f.MaybeSolarNight,
		MaybeCivilNight: f.MaybeCivilNight,
		MoonPhase:       f.MoonPhase,
		CreatedAt:       f.CreatedAt.Format(time.RFC3339),
		LastModified:    f.LastModified.Format(time.RFC3339),
		Active:          f.Active,
	})
}

Deletion in db/types.go at line 212 [11.161605]

B:BD[11.170702] → [11.170702:171607]

// MarshalJSON implements custom JSON marshaling for MothMetadata
// Formats timestamps as RFC3339
func (m MothMetadata) MarshalJSON() ([]byte, error) {
	return json.Marshal(&struct {
		FileID       string     `json:"file_id"`
		Timestamp    string     `json:"timestamp"`
		RecorderID   *string    `json:"recorder_id"`
		Gain         *GainLevel `json:"gain"`
		BatteryV     *float64   `json:"battery_v"`
		TempC        *float64   `json:"temp_c"`
		CreatedAt    string     `json:"created_at"`
		LastModified string     `json:"last_modified"`
		Active       bool       `json:"active"`
	}{
		FileID:       m.FileID,
		Timestamp:    m.Timestamp.Format(time.RFC3339),
		RecorderID:   m.RecorderID,
		Gain:         m.Gain,
		BatteryV:     m.BatteryV,
		TempC:        m.TempC,
		CreatedAt:    m.CreatedAt.Format(time.RFC3339),
		LastModified: m.LastModified.Format(time.RFC3339),
		Active:       m.Active,
	})
}

Deletion in db/types.go at line 221 [11.161605]

B:BD[11.171882] → [11.171882:172405]

// MarshalJSON implements custom JSON marshaling for FileDataset
// Formats timestamps as RFC3339
func (fd FileDataset) MarshalJSON() ([]byte, error) {
	return json.Marshal(&struct {
		FileID       string `json:"file_id"`
		DatasetID    string `json:"dataset_id"`
		CreatedAt    string `json:"created_at"`
		LastModified string `json:"last_modified"`
	}{
		FileID:       fd.FileID,
		DatasetID:    fd.DatasetID,
		CreatedAt:    fd.CreatedAt.Format(time.RFC3339),
		LastModified: fd.LastModified.Format(time.RFC3339),
	})
}

Deletion in cmd/pattern.go at line 12 [12.897]

B:BD[12.982] → [12.982:1156]

B:BD[12.1156] → [2.4973:5002]

∅:D[2.5002] → [12.1185:1201]

B:BD[12.1185] → [12.1185:1201]

B:BD[12.1201] → [2.5003:5032]

∅:D[2.5032] → [12.1230:1352]

B:BD[12.1230] → [12.1230:1352]


// RunPattern handles the "pattern" subcommand
func RunPattern(args []string) {
	if len(args) < 1 {
		printPatternUsage()
		os.Exit(1)
	}
	switch args[0] {
	case "create":
		RunPatternCreate(args[1:])
	case "update":
		RunPatternUpdate(args[1:])
	default:
		fmt.Fprintf(os.Stderr, "Unknown pattern subcommand: %s\n\n", args[0])
		printPatternUsage()
		os.Exit(1)
	}
}

Deletion in cmd/pattern.go at line 13 [12.897]

B:BD[12.1353] → [12.1353:1898]

func printPatternUsage() {
	fmt.Fprintf(os.Stderr, "Usage: skraak pattern <subcommand> [options]\n\n")
	fmt.Fprintf(os.Stderr, "Subcommands:\n")
	fmt.Fprintf(os.Stderr, "  create    Create a new recording pattern\n")
	fmt.Fprintf(os.Stderr, "  update    Update an existing recording pattern\n")
	fmt.Fprintf(os.Stderr, "\nExamples:\n")
	fmt.Fprintf(os.Stderr, "  skraak pattern create --db ./db/skraak.duckdb --record 60 --sleep 1740\n")
	fmt.Fprintf(os.Stderr, "  skraak pattern update --db ./db/skraak.duckdb --id pattern123 --record 30\n")
}

Deletion in cmd/location.go at line 12 [12.5378]

B:BD[12.5463] → [12.5463:5641]

B:BD[12.5641] → [2.5116:5146]

∅:D[2.5146] → [12.5671:5687]

B:BD[12.5671] → [12.5671:5687]

B:BD[12.5687] → [2.5147:5177]

∅:D[2.5177] → [12.5717:5841]

B:BD[12.5717] → [12.5717:5841]


// RunLocation handles the "location" subcommand
func RunLocation(args []string) {
	if len(args) < 1 {
		printLocationUsage()
		os.Exit(1)
	}
	switch args[0] {
	case "create":
		RunLocationCreate(args[1:])
	case "update":
		RunLocationUpdate(args[1:])
	default:
		fmt.Fprintf(os.Stderr, "Unknown location subcommand: %s\n\n", args[0])
		printLocationUsage()
		os.Exit(1)
	}
}

Deletion in cmd/location.go at line 13 [12.5378]

B:BD[12.5842] → [12.5842:6445]

func printLocationUsage() {
	fmt.Fprintf(os.Stderr, "Usage: skraak location <subcommand> [options]\n\n")
	fmt.Fprintf(os.Stderr, "Subcommands:\n")
	fmt.Fprintf(os.Stderr, "  create    Create a new location\n")
	fmt.Fprintf(os.Stderr, "  update    Update an existing location\n")
	fmt.Fprintf(os.Stderr, "\nExamples:\n")
	fmt.Fprintf(os.Stderr, "  skraak location create --db ./db/skraak.duckdb --dataset abc123 --name \"Site A\" --lat -36.85 --lon 174.76 --timezone Pacific/Auckland\n")
	fmt.Fprintf(os.Stderr, "  skraak location update --db ./db/skraak.duckdb --id loc123 --name \"Updated Name\"\n")
}

Deletion in cmd/dataset.go at line 12 [12.10933]

B:BD[12.11008] → [12.11008:11146]

// RunDataset handles the "dataset" subcommand
func RunDataset(args []string) {
	if len(args) < 1 {
		printDatasetUsage()
		os.Exit(1)
	}

Deletion in cmd/dataset.go at line 13 [12.10933]

B:BD[12.11147] → [12.11147:11181]

B:BD[12.11181] → [2.5263:5292]

∅:D[2.5292] → [12.11210:11226]

B:BD[12.11210] → [12.11210:11226]

B:BD[12.11226] → [2.5293:5322]

∅:D[2.5322] → [12.11255:11523]

B:BD[12.11255] → [12.11255:11523]

B:BD[12.11523] → [13.71:165]

∅:D[13.165] → [12.11585:11694]

B:BD[12.11585] → [12.11585:11694]

B:BD[12.11694] → [13.166:382]

∅:D[13.382] → [12.11815:11931]

B:BD[12.11815] → [12.11815:11931]

	switch args[0] {
	case "create":
		RunDatasetCreate(args[1:])
	case "update":
		RunDatasetUpdate(args[1:])
	default:
		fmt.Fprintf(os.Stderr, "Unknown dataset subcommand: %s\n\n", args[0])
		printDatasetUsage()
		os.Exit(1)
	}
}
func printDatasetUsage() {
	fmt.Fprintf(os.Stderr, "Usage: skraak dataset <subcommand> [options]\n\n")
	fmt.Fprintf(os.Stderr, "Subcommands:\n")
	fmt.Fprintf(os.Stderr, "  create    Create a new dataset (type defaults to 'structured')\n")
	fmt.Fprintf(os.Stderr, "  update    Update an existing dataset\n")
	fmt.Fprintf(os.Stderr, "\nExamples:\n")
	fmt.Fprintf(os.Stderr, "  skraak dataset create --db ./db/skraak.duckdb --name \"Test Dataset\"\n")
	fmt.Fprintf(os.Stderr, "  skraak dataset create --db ./db/skraak.duckdb --name \"Training Data\" --type train\n")
	fmt.Fprintf(os.Stderr, "  skraak dataset update --db ./db/skraak.duckdb --id abc123 --name \"Updated Name\"\n")
}

Deletion in cmd/cluster.go at line 12 [12.15264]
B:BD[12.15349] → [12.15349:15350]
B:BD[12.15350] → [9.8900:9029]
∅:D[9.9029] → [12.15430:15450]
B:BD[12.15430] → [12.15430:15450]
B:BD[12.15450] → [9.9030:9061]
∅:D[9.9061] → [12.15472:15523]
B:BD[12.15472] → [12.15472:15523]
B:BD[12.15523] → [2.6351:6380]
∅:D[2.6380] → [12.15552:15568]
B:BD[12.15552] → [12.15552:15568]
B:BD[12.15568] → [2.6381:6410]
∅:D[2.6410] → [12.15597:15679]
B:BD[12.15597] → [12.15597:15679]
B:BD[12.15679] → [9.9062:9093]
∅:D[9.9093] → [12.15701:15719]
B:BD[12.15701] → [12.15701:15719]
```
// RunRecordingCluster handles the "cluster" subcommand (for database cluster records)
func RunRecordingCluster(args []string) {
	if len(args) < 1 {
		printRecordingClusterUsage()
		os.Exit(1)
	}
	switch args[0] {
	case "create":
		RunClusterCreate(args[1:])
	case "update":
		RunClusterUpdate(args[1:])
	default:
		fmt.Fprintf(os.Stderr, "Unknown cluster subcommand: %s\n\n", args[0])
		printRecordingClusterUsage()
		os.Exit(1)
	}
}
```

Deletion in cmd/cluster.go at line 13 [12.15264]

B:BD[12.15720] → [9.9094:9130]

∅:D[9.9130] → [12.15747:16188]

B:BD[12.15747] → [12.15747:16188]

B:BD[12.16188] → [9.9131:9242]

∅:D[9.9242] → [12.16305:16307]

B:BD[12.16305] → [12.16305:16307]

func printRecordingClusterUsage() {
	fmt.Fprintf(os.Stderr, "Usage: skraak cluster <subcommand> [options]\n\n")
	fmt.Fprintf(os.Stderr, "Subcommands:\n")
	fmt.Fprintf(os.Stderr, "  create    Create a new cluster\n")
	fmt.Fprintf(os.Stderr, "  update    Update an existing cluster\n")
	fmt.Fprintf(os.Stderr, "\nExamples:\n")
	fmt.Fprintf(os.Stderr, "  skraak cluster create --db ./db/skraak.duckdb --dataset abc123 --location loc456 --name \"2024-01\" --sample-rate 250000\n")
	fmt.Fprintf(os.Stderr, "  skraak cluster update --db ./db/skraak.duckdb --id clust123 --name \"New Name\"\n")
}