INF-1307 zero out Go Report Card warnings + add badge

Ran every tool Go Report Card runs (gofmt, go vet, ineffassign, misspell,
gocyclo over 15, golint) and got each to clean. Specific cleanup:

- Refactored buildOperationCommand (cyclomatic complexity 57 -> < 15) by
  splitting into bindParameters, bindBodyFlags, runOperation,
  buildEndpoint, executeRequest helpers
- Refactored runCatalog (20) and printDescribe (16) the same way
- Removed dead `_ = typ` line from parameter binding
- Removed unused pathItem field from the opEntry struct
- Added missing doc comments on exported symbols in internal/config
  (SandboxBaseURL, EnvSandbox, BaseURL) and internal/updater
  (Asset, PromptResponse iota)
- Dropped the duplicate package-level comment on operations.go

scripts/lint.sh runs the same six tools locally; ci.yml gains a lint job
that installs them and runs the script, so regressions surface before
goreportcard.com sees them.

Badges (CI, Go Report Card, MIT) added to the README header.

Author: brtkwr

.github/workflows/ci.yml

@@ -19,5 +19,21 @@ jobs:
           go-version: '1.26'
           cache: true
       - run: go build ./...
-      - run: go vet ./...
       - run: go test ./...
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-go@v6
+        with:
+          go-version: '1.26'
+          cache: true
+      - name: Install lint tools
+        run: |
+          go install github.com/gordonklaus/ineffassign@latest
+          go install github.com/client9/misspell/cmd/misspell@latest
+          go install github.com/fzipp/gocyclo/cmd/gocyclo@latest
+          go install golang.org/x/lint/golint@latest
+          echo "$(go env GOPATH)/bin" >> "$GITHUB_PATH"
+      - run: ./scripts/lint.sh

README.md

@@ -1,5 +1,9 @@
 # twoctl
 
+[![ci](https://github.com/two-inc/twoctl/actions/workflows/ci.yml/badge.svg)](https://github.com/two-inc/twoctl/actions/workflows/ci.yml)
+[![Go Report Card](https://goreportcard.com/badge/github.com/two-inc/twoctl)](https://goreportcard.com/report/github.com/two-inc/twoctl)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
 Command-line interface for the [Two](https://two.inc) merchant APIs. Generated from the [public OpenAPI specs](https://github.com/two-inc/docs/tree/main/openapi), so every endpoint is exposed as a subcommand.
 
 ## Install

cmd/twoctl/cli/catalog.go

@@ -33,8 +33,8 @@ type catalogFlag struct {
 }
 
 type catalogOp struct {
-	Command      string        `json:"command"`        // e.g. "twoctl checkout create-order"
-	API          string        `json:"api"`            // "checkout"
+	Command      string        `json:"command"` // e.g. "twoctl checkout create-order"
+	API          string        `json:"api"`     // "checkout"
 	OperationID  string        `json:"operation_id,omitempty"`
 	Method       string        `json:"method"`
 	Path         string        `json:"path"`
@@ -46,69 +46,83 @@ type catalogOp struct {
 
 func runCatalog(cmd *cobra.Command, args []string) error {
 	wantAPI, _ := cmd.Flags().GetString("api")
-	var out []catalogOp
+	out, err := collectCatalog(wantAPI)
+	if err != nil {
+		return err
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].Command < out[j].Command })
+	enc := json.NewEncoder(cmd.OutOrStdout())
+	enc.SetIndent("", "  ")
+	return enc.Encode(out)
+}
 
+func collectCatalog(wantAPI string) ([]catalogOp, error) {
+	var out []catalogOp
 	for _, m := range apiMeta {
 		if wantAPI != "" && wantAPI != m.use {
 			continue
 		}
-		raw, err := specFS.ReadFile("specs/" + m.file)
+		doc, err := loadEmbeddedSpec(m.file)
 		if err != nil {
-			return err
+			return nil, err
 		}
-		doc, err := openapi3.NewLoader().LoadFromData(raw)
-		if err != nil {
-			return err
+		for _, e := range walkOperations(doc) {
+			out = append(out, catalogEntryFor(m.use, e))
 		}
-		for path, item := range doc.Paths.Map() {
-			for method, op := range item.Operations() {
-				if op == nil {
-					continue
-				}
-				name := commandNameFor(op, method, path)
-				for _, s := range stripSuffixes {
-					if len(name) > len(s) && name[len(name)-len(s):] == s {
-						name = name[:len(name)-len(s)]
-						break
-					}
-				}
-				entry := catalogOp{
-					Command:     "twoctl " + m.use + " " + name,
-					API:         m.use,
-					OperationID: op.OperationID,
-					Method:      method,
-					Path:        path,
-					Summary:     op.Summary,
-				}
-				for _, ref := range op.Parameters {
-					p := ref.Value
-					if p == nil {
-						continue
-					}
-					t := "string"
-					if p.Schema != nil && p.Schema.Value != nil && p.Schema.Value.Type != nil {
-						if s := p.Schema.Value.Type.Slice(); len(s) > 0 {
-							t = s[0]
-						}
-					}
-					entry.Flags = append(entry.Flags, catalogFlag{
-						Name:     toKebab(p.Name),
-						In:       p.In,
-						Type:     t,
-						Required: p.Required,
-						Desc:     p.Description,
-					})
-				}
-				if op.RequestBody != nil && op.RequestBody.Value != nil {
-					entry.HasBody = true
-					entry.BodyRequired = op.RequestBody.Value.Required
-				}
-				out = append(out, entry)
-			}
+	}
+	return out, nil
+}
+
+func loadEmbeddedSpec(file string) (*openapi3.T, error) {
+	raw, err := specFS.ReadFile("specs/" + file)
+	if err != nil {
+		return nil, err
+	}
+	return openapi3.NewLoader().LoadFromData(raw)
+}
+
+func catalogEntryFor(api string, e opEntry) catalogOp {
+	entry := catalogOp{
+		Command:     "twoctl " + api + " " + e.name,
+		API:         api,
+		OperationID: e.op.OperationID,
+		Method:      e.method,
+		Path:        e.path,
+		Summary:     e.op.Summary,
+		Flags:       catalogFlagsFor(e.op),
+	}
+	if e.op.RequestBody != nil && e.op.RequestBody.Value != nil {
+		entry.HasBody = true
+		entry.BodyRequired = e.op.RequestBody.Value.Required
+	}
+	return entry
+}
+
+func catalogFlagsFor(op *openapi3.Operation) []catalogFlag {
+	var flags []catalogFlag
+	for _, ref := range op.Parameters {
+		p := ref.Value
+		if p == nil {
+			continue
 		}
+		flags = append(flags, catalogFlag{
+			Name:     toKebab(p.Name),
+			In:       p.In,
+			Type:     flagTypeOf(p),
+			Required: p.Required,
+			Desc:     p.Description,
+		})
 	}
-	sort.Slice(out, func(i, j int) bool { return out[i].Command < out[j].Command })
-	enc := json.NewEncoder(cmd.OutOrStdout())
-	enc.SetIndent("", "  ")
-	return enc.Encode(out)
+	return flags
+}
+
+func flagTypeOf(p *openapi3.Parameter) string {
+	sch := schemaOf(p)
+	if sch == nil || sch.Type == nil {
+		return "string"
+	}
+	if s := sch.Type.Slice(); len(s) > 0 {
+		return s[0]
+	}
+	return "string"
 }