Merge branch 'release/v0.2.0'

Author: peczenyj

.github/workflows/ci.yml

@@ -38,6 +38,9 @@ jobs:
       - name: Build
         run: go build ./cmd/structalign
 
+      - name: Test
+        run: go test ./...
+
       - name: Smoke test
         run: |
           go run ./cmd/structalign -inspect ./_example

CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2026-05-24
+
+### Added
+
+- Support Go package patterns via go/packages (closes #5)
+
+### Changed
+
+- Merge tag 'v0.1.0' into devel
+- Merge pull request #6 from peczenyj/feature/5-recursive-package-pattern
+
 ## [0.1.0] - 2026-05-24
 
 ### Added
@@ -20,6 +31,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Bind flags to a config struct; fix -width and -verbose help
 - Modernize to Go 1.25 idioms
+- Merge branch 'release/v0.1.0'
 
 ### Fixed
 
@@ -37,6 +49,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Focus the README screenshot on the Record type
 - Document file/dir args instead of unsupported ./... (#5)
 
+[0.2.0]: https://github.com///compare/v0.1.0..v0.2.0
 [0.1.0]: https://github.com///tree/v0.1.0
 
 <!-- generated by git-cliff -->

CLAUDE.md

@@ -20,34 +20,52 @@ The module path is `github.com/peczenyj/structalign`, so the install target is
 ```
 go build -o structalign ./cmd/structalign     # produces ./structalign
 go vet ./...
-go run ./cmd/structalign [flags] <file.go | dir> [...]
+go test ./...                                  # unit + golden tests
+go test ./... -update                          # regenerate testdata/*.golden
+go run ./cmd/structalign [flags] [packages]   # packages: ./..., import paths, dirs, files
 go run ./cmd/structalign ./_example            # exercise diff mode
 go run ./cmd/structalign -inspect ./_example   # exercise inspect mode
 ```
 
-There are **no tests** in this repo. Verify changes by running the binary against
-`./_example` and eyeballing output. Exit code is meaningful: diff modes exit **1**
-when any reordering is found (CI-friendly), **0** when none; `-inspect` always
-exits 0.
+Tests live in `cmd/structalign/main_test.go` (same `package main`, so they reach
+unexported funcs). Two layers: table-driven unit tests for the pure helpers
+(`parsePatterns`, `matchAny`, `normalizeArgs`, `stripStructTags`, `relPath`,
+`lcsDiff`, `renderUnified`), and golden-file integration tests that run the real
+`loadPackages` → `diffPackage`/`inspectStructs` pipeline against `./_example` and
+compare to `testdata/*.golden`. The golden test `t.Chdir`s to the repo root so
+`./_example` resolves and paths render relative; regenerate fixtures with
+`-update`. Golden cases assume a **64-bit target** (`unsafe.Sizeof(uintptr) == 8`)
+and `t.Skip` otherwise, since `types.Sizes` depends on pointer width. Rendering is
+testable because `diffPackage`/`inspectStructs`/`render*` take an `io.Writer`
+(`main` passes `os.Stdout`).
+
+Exit code is meaningful: diff modes exit **1** when any reordering is found
+(CI-friendly), **0** when none; `-inspect` always exits 0.
 
 ## Core architecture
 
 The key design decision (see the package doc and README "How it works"): this tool
 **does not reimplement** the field-alignment algorithm. It runs the unmodified
 upstream `golang.org/x/tools/go/analysis/passes/fieldalignment.Analyzer` and
-intercepts the `SuggestedFix` it already produces. The pipeline in `process()`:
-
-1. `loadFiles` parses a `.go` file or every non-test `.go` in a directory as one package.
-2. Type-check with `go/types`, supplying `types.SizesFor("gc", "amd64")` so the
-   analyzer's size math is correct. The `types.Config.Error` callback swallows
-   errors so partially-resolving packages (missing deps) are still analyzed.
-3. Run the analyzer manually via an `analysis.Pass`, satisfying its only
-   dependency (the `inspect` pass) with `inspector.New(files)` in `Pass.ResultOf`.
-4. A custom `Pass.Report` captures each diagnostic's single `TextEdit`: `NewText`
+intercepts the `SuggestedFix` it already produces. The pipeline:
+
+1. `main` resolves the CLI args (`normalizeArgs` rewrites bare `.go` files to
+   `file=` queries) and `loadPackages` loads them via
+   `golang.org/x/tools/go/packages` (`./...`, import paths, dirs, files). This
+   gives syntax, types, type info, and `TypesSizes` for the real build target.
+2. Per package, `diffPackage` runs the analyzer via an `analysis.Pass`, wiring
+   `pkg.Syntax`/`pkg.Types`/`pkg.TypesInfo`/`pkg.TypesSizes` and satisfying its
+   only dependency (the `inspect` pass) with `inspector.New(pkg.Syntax)`.
+3. A custom `Pass.Report` captures each diagnostic's single `TextEdit`: `NewText`
    is the proposed reordered struct, and `readSource` reads the original source
    slice between the edit's `Pos`/`End`.
-5. `lcsDiff` diffs the two via `github.com/aymanbagabas/go-udiff` (`udiff.Lines`),
-   and `render` emits unified / side-by-side / proposed-only output.
+4. `lcsDiff` diffs the two via `github.com/aymanbagabas/go-udiff` (`udiff.Lines`),
+   and `render` emits unified / side-by-side / proposed-only output. Filenames
+   are shown relative to the working dir (`relPath`), since go/packages reports
+   absolute paths.
+
+Package load/type errors are reported to stderr but non-fatal — a
+partially-resolved package can still produce findings.
 
 **Why go-udiff and not x/tools' own diff:** Go's internal-package rule forbids
 importing `golang.org/x/tools/internal/diff` from a module not rooted under
@@ -62,9 +80,9 @@ to swap it back for the internal package — it won't compile from this module.
 
 ## Things to keep consistent when editing
 
-- **Architecture target is hardcoded** to `("gc", "amd64")` in `cmd/structalign/main.go`'s `process` and
-  reused for inspect. The README documents changing it for 32-bit targets — keep
-  both call sites in sync if you parameterize it.
+- **Type sizes come from `go/packages`** (`pkg.TypesSizes`), i.e. the toolchain's
+  real target (host `GOOS`/`GOARCH` by default; override via env). It is no longer
+  hardcoded to amd64.
 - **Struct name labeling** depends on `structNameIndex` mapping `StructType.Pos()`
   to the declared type name, because the analyzer reports diagnostics at exactly
   that position. Anonymous structs have no name and are filtered out by any

Makefile

@@ -27,6 +27,14 @@ fmt-check: ## Fail if any file is not gofmt'd
 		echo "Not gofmt'd:"; echo "$$unformatted"; exit 1; \
 	fi
 
+.PHONY: test
+test: ## Run the unit and golden tests
+	go test ./...
+
+.PHONY: test-update
+test-update: ## Regenerate the .golden fixtures under testdata
+	go test ./... -update
+
 .PHONY: smoke
 smoke: ## Exercise both modes against the bundled sample
 	go run $(PKG) -inspect $(SAMPLE)
@@ -35,7 +43,7 @@ smoke: ## Exercise both modes against the bundled sample
 	fi
 
 .PHONY: check
-check: fmt-check vet build smoke ## Run everything CI runs
+check: fmt-check vet build test smoke ## Run everything CI runs
 
 .PHONY: screenshot
 screenshot: build ## Regenerate docs/diff.png from colored output (needs python3 + pillow)

README.md

@@ -31,13 +31,15 @@ Or grab a prebuilt binary for your OS/arch from the
 [Releases](https://github.com/peczenyj/structalign/releases) page. Check the
 installed version with `structalign -version`.
 
-Then point it at a Go file or package directory (pass several to scan more than
-one at once):
+Then point it at a file, a package, or any Go package pattern:
 
 ```sh
-structalign ./path/to/pkg
+structalign ./...            # every package in the module (skips _* and testdata dirs)
 ```
 
+It accepts whatever the `go` tool does — `./...`, import paths, directories, and
+single `.go` files — and you can pass several at once.
+
 Pointed at the bundled sample (`./_example`), it reports the reordering and exits
 non-zero so it can gate CI:
 
@@ -74,7 +76,10 @@ inspect a struct's layout. `structalign` fills both gaps.
 ## Usage
 
 ```
-structalign [flags] <file.go | package-dir> [...]
+structalign [flags] [packages]
+
+  packages        Go package patterns: ./..., import paths, directories, or
+                  single .go files (defaults the go tool understands)
 
   -diff string    diff style: unified | side | none   (default "unified")
   -width int      column width per side for -diff=side (default: auto from terminal)
@@ -154,8 +159,9 @@ type Mixed struct { // size: 24, align: 8, padding: 14
 ```
 
 The layout comes from the same `go/types` sizing the diff modes use
-(`types.Sizes.Offsetsof` / `Sizeof` / `Alignof`), so it respects the `gc`/`amd64`
-target. This is similar to `honnef.co/go/tools/cmd/structlayout`, but stays inside
+(`types.Sizes.Offsetsof` / `Sizeof` / `Alignof`), driven by the toolchain's
+target sizes (your host `GOOS`/`GOARCH` by default). This is similar to
+`honnef.co/go/tools/cmd/structlayout`, but stays inside
 this one tool and honors the same `-type` filter.
 
 ### Filtering by type name
@@ -166,7 +172,7 @@ structs and struct literals are never matched by a non-empty filter. It applies
 every mode:
 
 ```sh
-structalign -type='*Request' ./pkg          # only structs ending in Request
+structalign -type='*Request' ./...          # only structs ending in Request
 structalign -type='Record,Config' ./pkg     # exact names
 structalign -inspect -type='*ID*' ./pkg     # inspect just ID-related structs
 ```
@@ -229,17 +235,20 @@ it as a package, so it stays out of `go build ./...` and friends.
   can occasionally induce false sharing between goroutines.
 - Reordering can hurt logical grouping/readability; treat the output as advice,
   most valuable for hot, frequently-allocated structs.
-- Sizes are computed for a target architecture (`amd64` here). 32-bit targets can
-  differ; change `types.SizesFor("gc", "...")` in `cmd/structalign/main.go` if needed.
+- Sizes are computed for the toolchain's target (your host `GOOS`/`GOARCH` by
+  default). To analyze another target, set them in the environment, e.g.
+  `GOARCH=386 structalign ./...`.
 
 ## Design notes
 
 ### Pipeline
 
-1. Type-check the target package with the stdlib (`go/types`), supplying
-   `types.SizesFor("gc", "amd64")` so the analyzer's size math is correct.
+1. Load the target packages with `golang.org/x/tools/go/packages` (mode
+   including syntax, types, type info, and `TypesSizes`). This resolves `./...`,
+   import paths, directories, and single files the way the `go` tool does, and
+   supplies the analyzer's size math from the real build target.
 2. Satisfy the analyzer's only dependency — the `inspect` pass — by building an
-   `inspector.New(files)` and placing it in `Pass.ResultOf`.
+   `inspector.New(pkg.Syntax)` and placing it in `Pass.ResultOf`.
 3. Provide a custom `Pass.Report` that captures each diagnostic's `NewText` (the
    proposed struct) and reads the original source slice between `Pos` and `End`.
 4. Diff the two with `github.com/aymanbagabas/go-udiff` (a maintained standalone