Update golangci-lint to v2.12.2 with canonical config (#62)

Updates golangci-lint to v2.12.2 everywhere it is pinned and installs the canonical `.golangci.yml`, then remediates every finding the new linter/config surfaces so `make check` is green.

## Version bump

- `Dockerfile` lint stage: `golangci/golangci-lint:v2.11.3-alpine` -> `v2.12.2-alpine` (digest-pinned, date comment updated)
- `Makefile` `deps` target: `go install` moved from the old v1 module path at `@latest` to the pinned `github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.12.2`
- `.golangci.yml` replaced with the canonical config (v2 schema; settings under `linters.settings` so the thresholds actually apply; `default: all` with the standard six disables)
- `script/bootstrap` installs golangci-lint via the system package manager and carries no version pin, so it is unchanged
- CI (`.gitea/workflows/check.yml`) only runs `script/cibuild`, so it needed no change

## Lint remediation

The canonical config surfaced ~3,300 findings across 56k lines. All are fixed, behavior-preserving; incorporates and supersedes the per-package mechanical passes already merged to `main` (refs #61). Highlights:

- `err113`: dynamic errors replaced with package sentinels + `%w` wrapping; comparisons via `errors.Is`
- `goprintffuncname`: printf-style helpers renamed with an `f` suffix (`ui.Writer` message methods, `cli.ReportErrorf`, `database.Fatalf`) and all call sites updated
- `revive` stutter renames: `blob.Handler`, `blob.WithReader`, `blob.ChunkPosition`, `storage.URL`, `storage.Info`; missing doc comments added
- `contextcheck`/`noctx`: `context.Context` threaded through `blob.Packer` and the scanner call sites; context-aware `exec`/`sql` variants
- `funlen`/`cyclop`/`gocognit`/`dupl`: oversized and duplicated functions split into focused helpers (production and test code)
- tests: `t.Parallel()` added where safe (global logger init kept in the serial phase for `-race`), `t.TempDir()`/`t.Helper()` adopted, several suites converted to external test packages
- `gosec`: bounded integer conversions, `ReadHeaderTimeout` on the test HTTP server; remaining warnings suppressed per-site with justifications
- remaining `nolint` directives are rare, targeted, and each carries a reason (e.g. `nilnil` not-found contract in the repository layer, fx module globals, on-disk snake_case struct tags)
- removed the deprecated `log.LogOptions` alias (callers migrated to `log.Options`)

`make check` (tests with `-race`, lint, fmt-check) passes.

Co-authored-by: sneak <sneak@sneak.berlin>
Reviewed-on: #62
Co-authored-by: clawbot <clawbot@noreply.example.org>
Co-committed-by: clawbot <clawbot@noreply.example.org>

internal/database/database.go

@@ -15,6 +15,7 @@ import (
 	"context"
 	"database/sql"
 	"embed"
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -22,10 +23,15 @@ import (
 	"strconv"
 	"strings"
 
+	// Register the pure-Go sqlite driver.
 	_ "modernc.org/sqlite"
 	"sneak.berlin/go/vaultik/internal/log"
 )
 
+// errInvalidMigrationFilename is returned when an embedded migration file
+// does not follow the "<version>[_<description>].sql" naming pattern.
+var errInvalidMigrationFilename = errors.New("invalid migration filename")
+
 //go:embed schema/*.sql
 var schemaFS embed.FS
 
@@ -51,7 +57,7 @@ type DB struct {
 func ParseMigrationVersion(filename string) (int, error) {
 	name := strings.TrimSuffix(filename, filepath.Ext(filename))
 	if name == "" {
-		return 0, fmt.Errorf("invalid migration filename %q: empty name", filename)
+		return 0, fmt.Errorf("%w %q: empty name", errInvalidMigrationFilename, filename)
 	}
 
 	// Split on underscore to separate version from description.
@@ -62,15 +68,17 @@ func ParseMigrationVersion(filename string) (int, error) {
 	}
 
 	if versionStr == "" {
-		return 0, fmt.Errorf("invalid migration filename %q: empty version prefix", filename)
+		return 0, fmt.Errorf(
+			"%w %q: empty version prefix", errInvalidMigrationFilename, filename,
+		)
 	}
 
 	// Validate the version is purely numeric.
 	for _, ch := range versionStr {
 		if ch < '0' || ch > '9' {
 			return 0, fmt.Errorf(
-				"invalid migration filename %q: version %q contains non-numeric character %q",
-				filename, versionStr, string(ch),
+				"%w %q: version %q contains non-numeric character %q",
+				errInvalidMigrationFilename, filename, versionStr, string(ch),
 			)
 		}
 	}
@@ -101,68 +109,87 @@ func New(ctx context.Context, path string) (*DB, error) {
 
 	conn, err := sql.Open(
 		"sqlite",
-		path+"?_journal_mode=WAL&_synchronous=NORMAL&_busy_timeout=10000&_locking_mode=NORMAL&_foreign_keys=ON",
+		path+"?_journal_mode=WAL&_synchronous=NORMAL&_busy_timeout=10000"+
+			"&_locking_mode=NORMAL&_foreign_keys=ON",
 	)
 	if err == nil {
-		// Set connection pool settings
-		// SQLite can handle multiple readers but only one writer at a time.
-		// Setting MaxOpenConns to 1 ensures all writes are serialized through
-		// a single connection, preventing SQLITE_BUSY errors.
-		conn.SetMaxOpenConns(1)
-		conn.SetMaxIdleConns(1)
+		configureConnPool(conn)
 
-		err := conn.PingContext(ctx)
+		err = conn.PingContext(ctx)
 		if err == nil {
 			// Success on first try
 			log.Debug("Database opened successfully with WAL mode", "path", path)
 
-			// Enable foreign keys explicitly
-			_, err = conn.ExecContext(ctx, "PRAGMA foreign_keys = ON")
-			if err != nil {
-				log.Warn("Failed to enable foreign keys", "error", err)
-			}
-
-			db := &DB{conn: conn, path: path}
-
-			err := applyMigrations(ctx, conn)
-			if err != nil {
-				_ = conn.Close()
-
-				return nil, fmt.Errorf("applying migrations: %w", err)
-			}
-
-			return db, nil
+			return finishOpen(ctx, conn, path)
 		}
 
-		log.Debug("Failed to ping database, closing connection", "path", path, "error", err)
+		log.Debug(
+			"Failed to ping database, closing connection",
+			"path", path, "error", err,
+		)
 
 		_ = conn.Close()
 	}
 
 	// If first attempt failed, try with TRUNCATE mode to clear any locks
+	return openWithRecovery(ctx, path)
+}
+
+// configureConnPool serializes all database access through one connection.
+// SQLite can handle multiple readers but only one writer at a time; setting
+// MaxOpenConns to 1 ensures all writes go through a single connection,
+// preventing SQLITE_BUSY errors.
+func configureConnPool(conn *sql.DB) {
+	conn.SetMaxOpenConns(1)
+	conn.SetMaxIdleConns(1)
+}
+
+// finishOpen enables foreign keys, wraps the connection, and applies any
+// pending migrations. On migration failure the connection is closed.
+func finishOpen(ctx context.Context, conn *sql.DB, path string) (*DB, error) {
+	// Enable foreign keys explicitly
+	_, err := conn.ExecContext(ctx, "PRAGMA foreign_keys = ON")
+	if err != nil {
+		log.Warn("Failed to enable foreign keys", "path", path, "error", err)
+	}
+
+	db := &DB{conn: conn, path: path}
+
+	err = applyMigrations(ctx, conn)
+	if err != nil {
+		_ = conn.Close()
+
+		return nil, fmt.Errorf("applying migrations: %w", err)
+	}
+
+	return db, nil
+}
+
+// openWithRecovery retries opening the database in TRUNCATE journal mode to
+// clear stale locks, then switches back to WAL mode.
+func openWithRecovery(ctx context.Context, path string) (*DB, error) {
 	log.Info(
 		"Database appears locked, attempting recovery with TRUNCATE mode",
 		"path", path,
 	)
 
-	conn, err = sql.Open(
+	conn, err := sql.Open(
 		"sqlite",
-		path+"?_journal_mode=TRUNCATE&_synchronous=NORMAL&_busy_timeout=10000&_foreign_keys=ON",
+		path+"?_journal_mode=TRUNCATE&_synchronous=NORMAL&_busy_timeout=10000"+
+			"&_foreign_keys=ON",
 	)
 	if err != nil {
 		return nil, fmt.Errorf("opening database in recovery mode: %w", err)
 	}
 
-	// Set connection pool settings
-	// SQLite can handle multiple readers but only one writer at a time.
-	// Setting MaxOpenConns to 1 ensures all writes are serialized through
-	// a single connection, preventing SQLITE_BUSY errors.
-	conn.SetMaxOpenConns(1)
-	conn.SetMaxIdleConns(1)
+	configureConnPool(conn)
 
 	err = conn.PingContext(ctx)
 	if err != nil {
-		log.Debug("Failed to ping database in recovery mode, closing", "path", path, "error", err)
+		log.Debug(
+			"Failed to ping database in recovery mode, closing",
+			"path", path, "error", err,
+		)
 
 		_ = conn.Close()
 
@@ -182,19 +209,9 @@ func New(ctx context.Context, path string) (*DB, error) {
 		log.Warn("Failed to switch back to WAL mode", "path", path, "error", err)
 	}
 
-	// Ensure foreign keys are enabled
-	_, err = conn.ExecContext(ctx, "PRAGMA foreign_keys=ON")
+	db, err := finishOpen(ctx, conn, path)
 	if err != nil {
-		log.Warn("Failed to enable foreign keys", "path", path, "error", err)
-	}
-
-	db := &DB{conn: conn, path: path}
-
-	err = applyMigrations(ctx, conn)
-	if err != nil {
-		_ = conn.Close()
-
-		return nil, fmt.Errorf("applying migrations: %w", err)
+		return nil, err
 	}
 
 	log.Debug("Database connection established successfully", "path", path)
@@ -202,6 +219,13 @@ func New(ctx context.Context, path string) (*DB, error) {
 	return db, nil
 }
 
+// NewTestDB creates an in-memory SQLite database for testing purposes.
+// The database is automatically initialized with the schema and is ready
+// for use. Each call creates a new independent database instance.
+func NewTestDB() (*DB, error) {
+	return New(context.Background(), ":memory:")
+}
+
 // Close closes the database connection.
 // It ensures all pending operations are completed before closing.
 // Returns an error if the database connection cannot be closed properly.
@@ -259,10 +283,11 @@ func (db *DB) ExecWithLog(
 	return db.conn.ExecContext(ctx, query, args...)
 }
 
-// QueryRowWithLog executes a query that returns at most one row with SQL logging.
-// This is useful for queries that modify data and return values (e.g., INSERT ... RETURNING).
-// SQLite handles its own locking internally.
-// The query and args parameters follow the same format as sql.DB.QueryRowContext.
+// QueryRowWithLog executes a query that returns at most one row with SQL
+// logging. This is useful for queries that modify data and return values
+// (e.g., INSERT ... RETURNING). SQLite handles its own locking internally.
+// The query and args parameters follow the same format as
+// sql.DB.QueryRowContext.
 func (db *DB) QueryRowWithLog(
 	ctx context.Context,
 	query string,
@@ -390,15 +415,8 @@ func applyMigrations(ctx context.Context, db *sql.DB) error {
 	return nil
 }
 
-// NewTestDB creates an in-memory SQLite database for testing purposes.
-// The database is automatically initialized with the schema and is ready for use.
-// Each call creates a new independent database instance.
-func NewTestDB() (*DB, error) {
-	return New(context.Background(), ":memory:")
-}
-
-// repeatPlaceholder generates a string of ", ?" repeated n times for IN clause construction.
-// For example, repeatPlaceholder(2) returns ", ?, ?".
+// repeatPlaceholder generates a string of ", ?" repeated n times for IN
+// clause construction. For example, repeatPlaceholder(2) returns ", ?, ?".
 func repeatPlaceholder(n int) string {
 	if n <= 0 {
 		return ""
@@ -408,12 +426,14 @@ func repeatPlaceholder(n int) string {
 }
 
 // LogSQL logs SQL queries and their arguments when debug mode is enabled.
-// Debug mode is activated by setting the GODEBUG environment variable to include "vaultik".
-// This is useful for troubleshooting database operations and understanding query patterns.
+// Debug mode is activated by setting the GODEBUG environment variable to
+// include "vaultik". This is useful for troubleshooting database operations
+// and understanding query patterns.
 //
-// The operation parameter describes the type of SQL operation (e.g., "Execute", "Query").
-// The query parameter is the SQL statement being executed.
-// The args parameter contains the query arguments that will be interpolated.
+// The operation parameter describes the type of SQL operation (e.g.,
+// "Execute", "Query"). The query parameter is the SQL statement being
+// executed. The args parameter contains the query arguments that will be
+// interpolated.
 func LogSQL(operation, query string, args ...any) {
 	if strings.Contains(os.Getenv("GODEBUG"), "vaultik") {
 		log.Debug(