Move the CLI to urfave/cli v3 (closes #110)

Ported per the library's v2-to-v3 migration guide: the app is a root
cli.Command, actions take a context and the command, and flag
environment variables become value sources. -v, -q and the version flag
are local so, as before, only the commands defining them accept them.
Every command stops reading flags at its first argument, as v2 did.
ErrWriter is stdout so usage errors print with their help. The action's
context reaches the manifest download in check, export and list.
testify rises to v1.12.1, which v3 requires; the urfave_cli_no_docs
build tag, which v3 lacks, is dropped. v3 accepts a flag given under two
names, so -v --verbose gives debug output, and the test pinning the
refusal becomes a TestVerboseCount case.

Model: opus-5-5

internal/cli/freshen.go

@@ -14,7 +14,7 @@ import (
 	"github.com/dustin/go-humanize"
 	"github.com/multiformats/go-multihash"
 	"github.com/spf13/afero"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 	"sneak.berlin/go/mfer/internal/log"
 	"sneak.berlin/go/mfer/mfer"
 )
@@ -202,12 +202,12 @@ func (s *freshenScanner) walk(path string, info fs.FileInfo, walkErr error) erro
 
 // resolveFreshenManifestPath determines the manifest path from the CLI
 // arguments, searching directories for a manifest where needed.
-func (mfa *CLIApp) resolveFreshenManifestPath(ctx *cli.Context) (string, error) {
-	if ctx.Args().Len() == 0 {
+func (mfa *CLIApp) resolveFreshenManifestPath(cmd *cli.Command) (string, error) {
+	if cmd.Args().Len() == 0 {
 		return findManifest(mfa.Fs, ".")
 	}
 
-	arg := ctx.Args().Get(0)
+	arg := cmd.Args().Get(0)
 
 	info, statErr := mfa.Fs.Stat(arg)
 	if statErr == nil && info.IsDir() {
@@ -338,14 +338,14 @@ func writeFreshenedManifest(
 
 // newFreshenBuilder constructs the manifest builder configured from CLI
 // flags.
-func newFreshenBuilder(ctx *cli.Context) *mfer.Builder {
+func newFreshenBuilder(cmd *cli.Command) *mfer.Builder {
 	builder := mfer.NewBuilder()
-	if ctx.Bool("include-timestamps") {
+	if cmd.Bool("include-timestamps") {
 		builder.SetIncludeTimestamps(true)
 	}
 
 	// Set up signing options if sign-key is provided
-	if signKey := ctx.String("sign-key"); signKey != "" {
+	if signKey := cmd.String("sign-key"); signKey != "" {
 		builder.SetSigningOptions(&mfer.SigningOptions{
 			KeyID: mfer.GPGKeyID(signKey),
 		})
@@ -358,13 +358,13 @@ func newFreshenBuilder(ctx *cli.Context) *mfer.Builder {
 // freshenScan runs the scan phase against the loaded manifest entries
 // and returns the populated scanner and the count of removed files.
 func (mfa *CLIApp) freshenScan(
-	ctx *cli.Context, manifestPath, absBase string,
+	cmd *cli.Command, manifestPath, absBase string,
 	existingByPath map[string]*mfer.MFFilePath,
 ) (*freshenScanner, int64, error) {
 	log.Infof("scanning filesystem...")
 
 	startScan := time.Now()
-	showProgress := ctx.Bool("progress")
+	showProgress := cmd.Bool("progress")
 
 	// Leave out the manifest and a temp file left by an interrupted run,
 	// as gen does. A path that cannot be stat'd, normally because no file
@@ -382,8 +382,8 @@ func (mfa *CLIApp) freshenScan(
 		fs:              mfa.Fs,
 		absBase:         absBase,
 		excluded:        excluded,
-		includeDotfiles: ctx.Bool("include-dotfiles"),
-		followSymlinks:  ctx.Bool("follow-symlinks"),
+		includeDotfiles: cmd.Bool("include-dotfiles"),
+		followSymlinks:  cmd.Bool("follow-symlinks"),
 		showProgress:    showProgress,
 		existingByPath:  existingByPath,
 	}
@@ -433,7 +433,7 @@ func hashTotals(entries []*freshenEntry) (int64, int64) {
 // runFreshenHash processes every entry through the hasher, aborting if
 // the context is canceled.
 func runFreshenHash(
-	ctx *cli.Context, hasher *freshenHasher, entries []*freshenEntry,
+	ctx context.Context, hasher *freshenHasher, entries []*freshenEntry,
 ) error {
 	for _, e := range entries {
 		select {
@@ -479,18 +479,21 @@ func (mfa *CLIApp) loadExistingEntries(
 	return existingByPath, nil
 }
 
-func (mfa *CLIApp) freshenManifestOperation(ctx *cli.Context) error {
+func (mfa *CLIApp) freshenManifestOperation(
+	ctx context.Context, cmd *cli.Command,
+) error {
 	log.Debug("freshenManifestOperation()")
 
-	basePath := ctx.String("base")
-	showProgress := ctx.Bool("progress")
+	basePath := cmd.String("base")
+	showProgress := cmd.Bool("progress")
 
 	// Find manifest file
-	manifestPath, err := mfa.resolveFreshenManifestPath(ctx)
+	manifestPath, err := mfa.resolveFreshenManifestPath(cmd)
 	if err != nil {
 		return fmt.Errorf("freshen: %w", err)
 	}
 
+	//nolint:contextcheck // mfer loads a manifest without a context
 	existingByPath, err := mfa.loadExistingEntries(manifestPath)
 	if err != nil {
 		return err
@@ -502,7 +505,7 @@ func (mfa *CLIApp) freshenManifestOperation(ctx *cli.Context) error {
 	}
 
 	// Phase 1: Scan filesystem
-	scanner, removed, err := mfa.freshenScan(ctx, manifestPath, absBase,
+	scanner, removed, err := mfa.freshenScan(cmd, manifestPath, absBase,
 		existingByPath)
 	if err != nil {
 		return err
@@ -524,7 +527,7 @@ func (mfa *CLIApp) freshenManifestOperation(ctx *cli.Context) error {
 		totalHashBytes: totalHashBytes,
 		filesToHash:    filesToHash,
 		startHash:      time.Now(),
-		builder:        newFreshenBuilder(ctx),
+		builder:        newFreshenBuilder(cmd),
 	}
 
 	err = runFreshenHash(ctx, hasher, scanner.entries)
@@ -548,7 +551,7 @@ func (mfa *CLIApp) freshenManifestOperation(ctx *cli.Context) error {
 	}
 
 	// Write updated manifest atomically (write to temp, then rename)
-	err = writeFreshenedManifest(ctx.Context, mfa.Fs, hasher.builder, manifestPath)
+	err = writeFreshenedManifest(ctx, mfa.Fs, hasher.builder, manifestPath)
 	if err != nil {
 		return err
 	}