Skip excluded paths before looking at their errors (closes #16)

filepath.Walk hands its callback the error for a path it could not
read, such as a directory it cannot list. Both callbacks, in
walkAndProcess and countFiles, returned that error before they checked
the exclusions, so a directory that --exclude or --exclude-dotfiles
excluded still failed the run when it could not be listed. Given an
error, each callback now checks the exclusions first and skips an
excluded path. The new test excludes a directory that cannot be listed
and runs sum add and check over its parent.

Model: opus-5-5

Dockerfile

@@ -1,43 +1,35 @@
-# Lint phase
-# golangci/golangci-lint:v2.12.2, 2026-10-05
-FROM golangci/golangci-lint@sha256:5cceeef04e53efe1470638d4b4b4f5ceefd574955ab3941b2d9a68a8c9ad5240 AS lint
-WORKDIR /src
-COPY go.mod go.sum ./
-RUN go mod download
-COPY . .
-RUN golangci-lint run --config .golangci.yml ./...
-
-# Test phase. -race needs cgo and so a C compiler, which the Debian Go
-# image ships and the alpine one does not. The tests run as an
-# unprivileged user: root can read a file with mode 0000, so the
-# permission test would fail.
-# golang:1.25.7-trixie, 2026-10-06
-FROM golang@sha256:2b174ffcf56c7ad0c47d30d2630693265639ddf2a5141149c2da34db921791b4 AS test
-RUN useradd --create-home testuser
-USER testuser
-WORKDIR /src
-COPY go.mod go.sum ./
-RUN go mod download
-COPY . .
-RUN go test -timeout 90s -race -cover ./... || \
-    { echo "--- Rerunning with -v for details ---"; \
-      go test -timeout 90s -race -v ./...; exit 1; }
-
-# Build stage. Nothing is wanted from either phase above; the copies
-# are what make BuildKit build them first, so this stage cannot run
-# unless lint and test passed.
+# Build stage
 # golang 1.25-alpine, 2026-02-28
 FROM golang@sha256:f6751d823c26342f9506c03797d2527668d095b0a15f1862cddb4d927a7a4ced AS builder
-COPY --from=lint /src/go.sum /dev/null
-COPY --from=test /src/go.sum /dev/null
-RUN apk add --no-cache git make
-# A tar-stream context keeps the sender's file owners, which git refuses.
-RUN git config --system --add safe.directory /src
+
+RUN apk add --no-cache git make gcc musl-dev binutils-gold
+
+# golangci-lint v2.12.2, 2026-10-05
+RUN go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@c0d3ddc9cf3faa61a4e378e879ece580256d76e5
+# goimports v0.42.0
+RUN go install golang.org/x/tools/cmd/goimports@009367f5c17a8d4c45a961a3a509277190a9a6f0
+
 WORKDIR /src
 COPY go.mod go.sum ./
 RUN go mod download
+
 COPY . .
 
+# Run the checks as an unprivileged user. Root bypasses file mode bits, which
+# would make the permission tests (expecting EACCES on a 0000 file) spuriously
+# pass with no error. Caches live under /tmp (world-writable) so the user needs
+# no home directory of its own.
+ENV GOCACHE=/tmp/gocache
+ENV XDG_CACHE_HOME=/tmp/xdgcache
+RUN adduser -D -u 1000 builder && chown -R builder:builder /src /go
+USER builder
+
+# Run all checks - build fails if any check fails
+RUN make check
+
+# Build the binary (still as the unprivileged user: it owns /src, so git VCS
+# stamping sees consistent ownership).
+#
 # The version stamped into the binary: the VERSION build argument when one
 # is given, otherwise `git describe --tags --always` of the .git the build
 # context carries: the tag on a tagged commit, tag-N-gHASH on a commit after

README.md

@@ -95,9 +95,7 @@ Future improvements under consideration:
 
 * Author & maintainer: **sneak** – <sneak@sneak.berlin>
 * Issues / PRs: <https://git.eeqj.de/sneak/attrsum/>
-* Code must pass `make check`, which runs the tests and golangci-lint as
-  phases of the `Dockerfile` (Docker is required) and checks formatting
-  with `gofmt`.
+* Code must pass `go vet`, `go test ./...`, and `go fmt`.
 * No CLA; contributions are under WTFPL v2.
 
 ---

TODO.md

@@ -17,22 +17,16 @@ have landed since the tag.
 
 # Next Step
 
-Re-vendor the canonical files from `sneak/prompts` at `dd4027b`
-(https://git.eeqj.de/sneak/attrsum/issues/13): add `REPO_POLICIES.md`
-and `.editorconfig`, refresh `.gitignore` (only the `attrsum` binary
-today), `.dockerignore`, `.gitea/workflows/check.yml` and
-`.golangci.yml`, and move the lint phase to golangci-lint v2.14.0.
+Policy scaffold commit: add LICENSE, REPO_POLICIES.md, .editorconfig,
+.golangci.yml, and a comprehensive .gitignore (currently only the
+attrsum binary), and extend the Makefile (only test/build/clean/try
+today) with lint, fmt, fmt-check, check, and hooks targets.
 
 # Completed Steps
 
 * 2026-10-06: a path that `--exclude` or `--exclude-dotfiles` excludes
     is skipped even when it cannot be read, so an excluded directory
     that cannot be listed no longer fails the run
-* 2026-10-06: lint and test run as phases of the `Dockerfile`, and the
-    build stage depends on both; `script/lint` and `script/test` each
-    build their phase with `--no-cache`; `script/cibuild` bootstraps,
-    runs `script/check`, then builds the image; golangci-lint is no
-    longer installed on the host
 * 2026-10-06: `check --continue` keeps going past a file or directory
     it cannot read: it counts it as failed, prints the error and the
     path on stderr, and checks the rest of the tree
@@ -62,12 +56,11 @@ today), `.dockerignore`, `.gitea/workflows/check.yml` and
 
 # Future Steps
 
+* Add .gitea/workflows/check.yml
 * Restructure README.md into the standard sections: Description,
-    Getting Started, Entrypoints, Rationale, Design, TODO, License,
-    Author (Getting Started, Why?, TODO, License exist; Description,
-    Entrypoints, Design, Author are missing)
-* Add a `LICENSE` file matching the README's WTFPL v2; sneak's to add,
-    not an agent's
+    Getting Started, Rationale, Design, TODO, License, Author (Getting
+    Started, Why?, TODO, License exist; Description, Design, Author are
+    missing)
 * Tag a patch release to ship the 2026-02-02 correctness fixes
 * Dry-run mode (--dry-run, -n): show what would be done without making
     changes (from README TODO)

script/bootstrap

@@ -3,14 +3,15 @@
 # this repo. Idempotent: every install is guarded by a check so already
 # installed tools are skipped. Base tooling comes from nix, apt, brew,
 # or apk (detected in that order); assumes nothing is present.
-# goimports is installed via `go install` at a pinned commit (never
-# "latest"). The linter is not installed: it runs only as the lint phase
-# of the Dockerfile.
+# golangci-lint and goimports are installed via `go install` at the same
+# pinned commits the Dockerfile uses (never "latest").
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
-# Pinned versions, 2026-10-05
+# Pinned versions, 2026-10-05 (same pins as the Dockerfile)
+# golangci-lint v2.12.2
+GOLANGCI_LINT_REF="github.com/golangci/golangci-lint/v2/cmd/golangci-lint@c0d3ddc9cf3faa61a4e378e879ece580256d76e5"
 # goimports v0.42.0
 GOIMPORTS_REF="golang.org/x/tools/cmd/goimports@009367f5c17a8d4c45a961a3a509277190a9a6f0"
 
@@ -68,8 +69,9 @@ main() {
     if missing make; then pkg_install gnumake make make make; fi
     if missing go; then pkg_install go golang go go; fi
 
-    # Format tool, pinned via go install (installs into
+    # Lint/format tools, pinned via go install (installs into
     # "$(go env GOPATH)/bin"; ensure that is on your PATH).
+    if missing golangci-lint; then go install "$GOLANGCI_LINT_REF"; fi
     if missing goimports; then go install "$GOIMPORTS_REF"; fi
 
     go mod download

script/check

@@ -1,8 +1,6 @@
 #!/bin/sh
 # script/check: run all checks (test, lint, fmt-check). Our own
-# extension to scripts-to-rule-them-all. test and lint are Docker
-# phases; fmt-check is native, because a formatter writes the working
-# tree. Must not modify any files.
+# extension to scripts-to-rule-them-all. Must not modify any files.
 set -eu
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"

script/cibuild

@@ -1,28 +1,13 @@
 #!/bin/sh
-# script/cibuild: run the CI build. It bootstraps first: a CI runner
-# checks out and runs this and nothing else, and script/fmt-check runs
-# the formatter on the host, which a pristine checkout cannot do.
-# --no-cache for the same reason as script/docker: the gate phases the
-# final stage depends on are RUN steps, and a cached one is a check that
-# did not run.
+# script/cibuild: run the CI build. The Dockerfile runs make check, so
+# a successful build implies all checks pass.
 set -eu
 
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
-ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    "$SCRIPT_DIR/bootstrap"
-    "$SCRIPT_DIR/check"
-    # Own line: a failing command substitution inside an argument does
-    # not trip `set -e`, so the inline form degrades silently to an
-    # empty constant. The VERSION build argument takes precedence over
-    # the version a build stage derives from the .git in the context.
-    version="$(git describe --tags --always --dirty 2>/dev/null || true)"
-    [ -n "$version" ] || version="unknown"
-    docker build --no-cache \
-        --build-arg VERSION="$version" \
-        -t "$("$SCRIPT_DIR/projectname")" .
+    docker build .
 }
 
 main "$@"

script/lint

@@ -1,23 +1,12 @@
 #!/bin/sh
-# script/lint: run the linter. Linting is a phase of the Dockerfile and
-# this builds that phase alone; the linter is never installed or run on
-# a developer host, where a shared result cache and a host-global lock
-# make its answer untrustworthy.
-#
-# The phase is not the last stage in the file, so it is built only when
-# --target names it. --no-cache because a cached lint layer is a lint
-# that did not run. The tag makes each build replace the previous image
-# instead of leaving a dangling one behind.
+# script/lint: run the linter.
 set -eu
 
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
-ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    docker build --no-cache \
-        --target lint \
-        -t "$("$SCRIPT_DIR/projectname")-lint" .
+    golangci-lint run --config .golangci.yml ./...
 }
 
 main "$@"

script/test

@@ -1,19 +1,12 @@
 #!/bin/sh
-# script/test: run the test suite. Testing is a phase of the Dockerfile
-# and this builds that phase alone, on the same terms as script/lint:
-# --target because a phase that is not the last stage is built only when
-# named, --no-cache because a cached test layer is a test that did not
-# run, and a tag so each build replaces the previous image.
+# script/test: run the test suite.
 set -eu
 
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
-ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    docker build --no-cache \
-        --target test \
-        -t "$("$SCRIPT_DIR/projectname")-test" .
+    go test -v -race -timeout 30s -cover ./...
 }
 
 main "$@"