Fix lint findings · Entire

Fix lint findings

e941481→main·

golangci-lint v2.11.4 was unhappy across errcheck, exhaustive, gocritic, inamedparam, ireturn, maintidx, noctx, perfsprint, revive, and wrapcheck. Mostly mechanical:

- Test helpers (initSHA1, initSHA256, mustTranslator) collapse the '_ := ' patterns into t.Fatalf-on-error wrappers. - exec.Command -> exec.CommandContext(ctx, ...); ctx threaded into runChecks and signBranchTips. - refs.ForEach return value checked instead of discarded. - if/else chain in runChecks rewritten as switch. - ireturn for openSource/normalizeAuth annotated, since both return shared transport interfaces by design. - maintidx on Run annotated; the function is a phase orchestrator, splitting it would obscure the pipeline. - exhaustive switches on plumbing.ObjectType annotated; the unhandled cases (OFSDelta/REFDelta/AnyObject/InvalidObject) can't reach a resolved storer. - Errors from io.ReadAll/MemoryObject.Reader/bufio.Flush/fmt.Fprintln/ auth.Method.Authorizer wrapped with fmt.Errorf. - Constant 'max' renamed to package-level 'previewMax' to stop shadowing the builtin in two places. - Named parameter added to interface methods that lint flagged. - Two fmt.Sprintf calls replaced with string concatenation.

Sessions

Transcript data is unavailable for this checkpoint.

Changes

2

131 unmodified lines

// previewMax caps how many items from a potentially-long list (ambiguous // prefixes, signed tags) are inlined into a Lines() summary before // switching to a "(N more)" suffix. const previewMax = 5

// Lines satisfies the human-readable output contract used by other git-sync subcommands. func (r Result) Lines() []string { lines := []string{ fmt.Sprintf("sha256 bare repo: %s", r.TargetDir), "sha256 bare repo: " + r.TargetDir, fmt.Sprintf("source: %s (%s)", r.SourceURL, r.Protocol), fmt.Sprintf("converted: %d blobs, %d trees, %d commits, %d tags", r.Counts.Blobs, r.Counts.Trees, r.Counts.Commits, r.Counts.Tags), } if n := len(r.AmbiguousMessageRefs); n > 0 { preview := r.AmbiguousMessageRefs const max = 5 extra := 0 if len(preview) > max { extra = len(preview) - max preview = preview[:max] } if len(preview) > previewMax { extra = len(preview) - previewMax preview = preview[:previewMax] } line := fmt.Sprintf("warning: %d ambiguous SHA1 hex prefix(es) in messages left unrewritten (look up via the mapping file): %s", n, strings.Join(preview, ", "))

lines = append(lines, line) } if r.MappingFile != "" { lines = append(lines, fmt.Sprintf("mapping written to: %s", r.MappingFile)) lines = append(lines, "mapping written to: " + r.MappingFile) } if n := len(r.SignedTags); n > 0 { preview := r.SignedTags const max = 5 extra := 0 if len(preview) > max { extra = len(preview) - max preview = preview[:max] } if len(preview) > previewMax { extra = len(preview) - previewMax preview = preview[:previewMax] } line := fmt.Sprintf("signed %d branch attestation tag(s): %s", n, strings.Join(preview, ", "))

lines = append(lines, line) } if r.TempDir != "" { lines = append(lines, fmt.Sprintf("kept source objects: %s", r.TempDir)) lines = append(lines, "kept source objects: " + r.TempDir) } return lines }

// Run performs the conversion described by req. //nolint:maintidx // Run is a linear orchestrator over distinct phases (fetch → discover → init → translate → refs → notes → mapping → sign → check); each phase is short and isolated. Splitting into helpers would obscure the pipeline rather than clarify it. func Run(ctx context.Context, req Request) (Result, error) { if req.SourceURL == "" { return Result{}, errors.New("convert-sha256 requires --source-url") }

if req.Sign { signed, err := signBranchTips(out, req.TargetDir, req.SignKey, req.SourceURL, desired) if err != nil { return res, fmt.Errorf("sign: %w", err) } }

if req.Check { fmt.Fprintln(out, "verifying output ...") res.Checks = runChecks(req.TargetDir, dstRepo, refsWritten) for _, c := range res.Checks { mark := "✓" if !c.OK { mark = "✗" } fmt.Fprintf(out, "%s %s ", mark, c.Name) } } return res, nil }

// stdin/stderr are inherited so gpg/ssh-agent prompts work // interactively. A failure short-circuits the run; tags signed before // the failure stay in the target repo. func signBranchTips(out io.Writer, targetDir, signKey, sourceURL string, desired map[plumbing.ReferenceName]planner.DesiredRef) ([]string, error) { gitBin, err := exec.LookPath("git") if err != nil { return nil, fmt.Errorf("git binary required to sign: %w", err) }

args := []string{" return nil }

// Returns one Check per step. Callers print and/or fail-on-error based // on these. No early return so users see the full picture even when an // earlier check fails. func runChecks(targetDir string, repo *git.Repository, refsExpected int) []Check { checks := []Check{}

// 1. Config: extensions.objectformat = sha256. // example code, unfinished.
}

// outline of logic continues.