quietlight/skraak_mcp - Change IK7B2IKI726M74IEPSJZXFMTCV2CTJFFIDDF2QBLONGBSBUNJFNQC

fixing lint errors

Created by quietlight on April 19, 2026

IK7B2IKI726M74IEPSJZXFMTCV2CTJFFIDDF2QBLONGBSBUNJFNQC

Dependencies

In channels

main

Change contents

Replacement in tui/classify.go at line 584 [6.9978]
B:BD[5.1473] → [3.322:360]
```
		utils.ClearImages(&b, m.protocol())
```
[5.1473]
[5.1502]
```
		_ = utils.ClearImages(&b, m.protocol())
```

Replacement in tui/classify.go at line 729 [6.9978]

B:BD[7.944] → [3.423:520]

∅:D[3.520] → [8.2246:2282]

∅:D[7.944] → [8.2246:2282]

B:BD[8.2246] → [8.2246:2282]

B:BD[8.2282] → [9.2517:2562]

		// Clear previous kitty images before writing new one
		utils.ClearImages(os.Stdout, protocol)
		fmt.Fprint(os.Stdout, "\r\n\r\n")
		utils.WriteImage(img, os.Stdout, protocol)

[7.944]

[8.2322]

		// Clear previous kitty images before writing new one.
		// Terminal write errors during render are non-recoverable; ignore.
		_ = utils.ClearImages(os.Stdout, protocol)
		_, _ = fmt.Fprint(os.Stdout, "\r\n\r\n")
		_ = utils.WriteImage(img, os.Stdout, protocol)

Replacement in tools/import_unstructured.go at line 266 [10.1]

B:BD[10.7384] → [10.7384:7425]

		filepath.WalkDir(folderPath, walkFunc)

[10.7384]

[10.7425]

		if err := filepath.WalkDir(folderPath, walkFunc); err != nil {
			errors = append(errors, utils.FileImportError{
				FileName: folderPath,
				Error:    err.Error(),
				Stage:    "scan",
			})
		}

Replacement in tools/calls_from_raven.go at line 215 [11.1]

B:BD[11.5582] → [11.5582:5692]

		fmt.Sscanf(fields[beginTimeIdx], "%f", &sel.StartTime)
		fmt.Sscanf(fields[endTimeIdx], "%f", &sel.EndTime)

[11.5582]

[11.5692]

		if _, err := fmt.Sscanf(fields[beginTimeIdx], "%f", &sel.StartTime); err != nil {
			return nil, false, false, fmt.Errorf("failed to parse begin time %q: %w", fields[beginTimeIdx], err)
		}
		if _, err := fmt.Sscanf(fields[endTimeIdx], "%f", &sel.EndTime); err != nil {
			return nil, false, false, fmt.Errorf("failed to parse end time %q: %w", fields[endTimeIdx], err)
		}

Replacement in tools/calls_from_raven.go at line 222 [11.1]

B:BD[11.5743] → [11.5743:5797]

			fmt.Sscanf(fields[lowFreqIdx], "%f", &sel.FreqLow)

[11.5743]

[11.5797]

			if _, err := fmt.Sscanf(fields[lowFreqIdx], "%f", &sel.FreqLow); err != nil {
				return nil, false, false, fmt.Errorf("failed to parse low freq %q: %w", fields[lowFreqIdx], err)
			}

Replacement in tools/calls_from_raven.go at line 227 [11.1]

B:BD[11.5854] → [11.5854:5910]

			fmt.Sscanf(fields[highFreqIdx], "%f", &sel.FreqHigh)

[11.5854]

[11.5910]

			if _, err := fmt.Sscanf(fields[highFreqIdx], "%f", &sel.FreqHigh); err != nil {
				return nil, false, false, fmt.Errorf("failed to parse high freq %q: %w", fields[highFreqIdx], err)
			}

Replacement in tools/calls_from_birda.go at line 217 [11.19597]

B:BD[11.25310] → [11.25310:25412]

		fmt.Sscanf(record[startIdx], "%f", &det.StartTime)
		fmt.Sscanf(record[endIdx], "%f", &det.EndTime)

[11.25310]

[11.25412]

		if _, err := fmt.Sscanf(record[startIdx], "%f", &det.StartTime); err != nil {
			return nil, false, false, fmt.Errorf("failed to parse start time %q: %w", record[startIdx], err)
		}
		if _, err := fmt.Sscanf(record[endIdx], "%f", &det.EndTime); err != nil {
			return nil, false, false, fmt.Errorf("failed to parse end time %q: %w", record[endIdx], err)
		}

Replacement in tools/calls_from_birda.go at line 224 [11.19597]

B:BD[11.25453] → [11.25453:25512]

		fmt.Sscanf(record[confidenceIdx], "%f", &det.Confidence)

[11.25453]

[11.25512]

		if _, err := fmt.Sscanf(record[confidenceIdx], "%f", &det.Confidence); err != nil {
			return nil, false, false, fmt.Errorf("failed to parse confidence %q: %w", record[confidenceIdx], err)
		}

Replacement in tools/bulk_file_import.go at line 68 [12.1]

B:BD[12.2075] → [12.2075:2180]

	// Write to file
	l.file.WriteString(line)
	l.file.Sync() // Ensure immediate write for tail monitoring

[12.2075]

[12.2180]

	// Write to file; log write failures are non-fatal for import progress
	if _, err := l.file.WriteString(line); err != nil {
		fmt.Fprintf(os.Stderr, "Warning: log write failed: %v\n", err)
	}
	if err := l.file.Sync(); err != nil {
		fmt.Fprintf(os.Stderr, "Warning: log sync failed: %v\n", err)
	}

Replacement in db/db.go at line 21 [13.330289]

B:BD[13.330819] → [13.330819:330832]

		db.Close()

[13.330819]

[13.330832]

		closeErr := db.Close()
		if closeErr != nil {
			return nil, fmt.Errorf("failed to ping database: %w (close error: %v)", err, closeErr)
		}

Replacement in db/db.go at line 42 [13.330289]

B:BD[13.331338] → [13.331338:331351]

		db.Close()

[13.331338]

[13.331351]

		closeErr := db.Close()
		if closeErr != nil {
			return nil, fmt.Errorf("failed to ping database: %w (close error: %v)", err, closeErr)
		}

Replacement in cmd/xxhash.go at line 52 [14.1]

B:BD[14.1171] → [14.1171:1191]

	enc.Encode(output)

[14.1171]

[14.1191]

	if err := enc.Encode(output); err != nil {
		fmt.Fprintf(os.Stderr, "Error encoding output: %v\n", err)
		os.Exit(1)
	}

Replacement in cmd/time.go at line 39 [15.1]

B:BD[15.841] → [15.841:861]

	enc.Encode(output)

[15.841]

[15.861]

	if err := enc.Encode(output); err != nil {
		fmt.Fprintf(os.Stderr, "Error encoding output: %v\n", err)
		os.Exit(1)
	}

Replacement in cmd/sql.go at line 67 [16.18]

B:BD[16.1592] → [16.1592:1612]

	enc.Encode(output)

[16.1592]

[16.1612]

	if err := enc.Encode(output); err != nil {
		fmt.Fprintf(os.Stderr, "Error encoding output: %v\n", err)
		os.Exit(1)
	}

Replacement in cmd/prepend.go at line 66 [17.11036]

B:BD[17.13051] → [17.13051:13071]

	enc.Encode(output)

[17.13051]

[17.13071]

	if err := enc.Encode(output); err != nil {
		fmt.Fprintf(os.Stderr, "Error encoding output: %v\n", err)
		os.Exit(1)
	}

Replacement in cmd/metadata.go at line 66 [14.1229]

B:BD[14.2888] → [14.2888:2908]

	enc.Encode(output)

[14.2888]

[14.2908]

	if err := enc.Encode(output); err != nil {
		fmt.Fprintf(os.Stderr, "Error encoding output: %v\n", err)
		os.Exit(1)
	}

Insertion in cmd/isnight.go at line 60 [18.4631]
[18.6692]
[18.6692]
```
	var encErr error
```
Replacement in cmd/isnight.go at line 63 [18.4631]
B:BD[18.6741] → [18.6741:6770]
```
		enc.Encode(map[string]any{
```
[18.6741]
[18.6770]
```
		encErr = enc.Encode(map[string]any{
```

Replacement in cmd/isnight.go at line 70 [18.4631]

B:BD[18.6919] → [18.6919:6940]

		enc.Encode(output)

[18.6919]

[18.6940]

		encErr = enc.Encode(output)
	}
	if encErr != nil {
		fmt.Fprintf(os.Stderr, "Error encoding output: %v\n", encErr)
		os.Exit(1)

Replacement in cmd/import.go at line 436 [16.9244]

B:BD[16.12231] → [16.12231:12246]

	enc.Encode(v)

[16.12231]

[16.12246]

	if err := enc.Encode(v); err != nil {
		fmt.Fprintf(os.Stderr, "Error encoding output: %v\n", err)
		os.Exit(1)
	}

Replacement in cmd/export.go at line 96 [19.39342]

B:BD[19.42213] → [19.42213:42239]

	enc.Encode(outputResult)

[19.42213]

[19.42239]

	if err := enc.Encode(outputResult); err != nil {
		fmt.Fprintf(os.Stderr, "Error encoding output: %v\n", err)
		os.Exit(1)
	}

Insertion in cmd/common.go at line 2 [2.1]
[2.14]
[2.14]
```
import (
	"fmt"
	"os"
```
Replacement in cmd/common.go at line 7 [2.1]
B:BD[2.15] → [2.15:34]
```
import "skraak/db"
```
[2.15]
[2.34]
```
	"skraak/db"
)
```

Replacement in cmd/common.go at line 17 [2.1]

B:BD[2.327] → [2.327:365]

	return func() { db.CloseEventLog() }

[2.327]

[2.365]

	return func() {
		if err := db.CloseEventLog(); err != nil {
			fmt.Fprintf(os.Stderr, "Warning: failed to close event log: %v\n", err)
		}
	}

Replacement in cmd/calls_push_certainty.go at line 190 [20.6061]

B:BD[20.11348] → [20.11348:11368]

	enc.Encode(result)

[20.11348]

[20.11368]

	if err := enc.Encode(result); err != nil {
		fmt.Fprintf(os.Stderr, "Error encoding output: %v\n", err)
		os.Exit(1)
	}

Insertion in .golangci.yml at line 3 [4.1]

[4.16]

# errcheck stays ENABLED. We exclude only specific method signatures that are
# universally safe to ignore (defer close on read paths, rollback-after-commit,
# test helpers). Real production error paths must still be checked.

Replacement in .golangci.yml at line 8 [4.1]

B:BD[4.25] → [4.25:82]

  default: none
  enable:
    - staticcheck
    - unused

[4.25]

  default: standard
  settings:
    errcheck:
      exclude-functions:
        # defer Close() on read-only or already-errored resources — the open
        # error and read errors are what matter; close errors on these paths
        # are non-actionable.
        - (*database/sql.DB).Close
        - (*database/sql.Rows).Close
        - (*database/sql.Stmt).Close
        - (*os.File).Close
        # Rollback after a successful Commit is a no-op; rollback on the error
        # path can't meaningfully recover either. Idiomatic pattern:
        # `defer tx.Rollback()` right after `BeginTx`.
        - (*database/sql.Tx).Rollback
        # Our wrapper types around database/sql — same semantics as above.
        - (*skraak/db.LoggedTx).Rollback
        - (*skraak/db.LoggedStmt).Close
        # Test cleanup — failures don't affect test validity.
        - os.Remove
        - os.RemoveAll
  exclusions:
    rules:
      # Test files: binary.Write to in-memory buffers cannot fail; json.Unmarshal
      # in assertions is checked by subsequent field reads; tx/stmt calls whose
      # results are verified by later queries.
      - path: _test\.go
        linters:
          - errcheck