add issue report limits

upd conglangci-lint action

.github/workflows/golang-ci.yml

@@ -2,11 +2,11 @@ name: CI
 
 on:
   push:
-    branches: [ "main" ]
+    branches: ['main']
     paths:
       - '**.go'
   pull_request:
-    branches: [ "main" ]
+    branches: ['main']
     paths:
       - '**.go'
 jobs:
@@ -23,7 +23,8 @@ jobs:
         uses: actions/setup-go@v5
         with:
           go-version: '1.24'
-      - name: Install golangci-lint
+      - name: golangci-lint
-        run: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
+        uses: golangci/golangci-lint-action@v9
-      - name: Run golangci-lint
+        with:
-        run: golangci-lint run ./...
+          version: v2.6.0
+          args: --config .golangci.yml

.golangci.yml

@@ -1,55 +1,144 @@
+version: '2'
+
 run:
-  # timeout for analysis, e.g. 30s, 3m, default is 1m
   timeout: 3m
-  # exclude test files
   tests: true
+  go: '1.24'
 
 linters:
-  # Set to true runs only fast linters.
+  disable: [dupl]
-  # Good option for 'lint on save', pre-commit hook or CI.
-  fast: true
-
-  disable-all: true
-
   enable:
-    - gosimple
+    # Default enabled linters
-    - govet
+    - errcheck # Check for unchecked errors
-    - ineffassign
+    - govet # Go's built-in vetting tool
-    - staticcheck
+    - ineffassign # Detect ineffectual assignments
-    - unused
+    - staticcheck # Advanced static analysis
-    - gofmt
+    - unused # Check for unused code
-    - gofumpt
+    # Additional useful linters
-    - misspell
+    - misspell # Detect common misspellings
-    - unparam
+    - unparam # Check for unused function parameters
-    - gosec
+    - gosec # Security checks
-    - asciicheck
+    - asciicheck # Check for non-ASCII characters
-    - errname
+    - errname # Check error variable names
-    - gci
+    - godot # Check for missing periods in comments
-    - godot
+    - revive # Highly configurable linter for style and correctness
-    - goimports
+    - gocritic # Detect code issues and suggest improvements
-    - revive
+    - gocyclo # Check for cyclomatic complexity
+    - dupl # Check for code duplication
+    - predeclared # Check for shadowing of predeclared identifiers
+    - copyloopvar # Check for loop variable capture in goroutines
+    - errorlint # Check for common mistakes in error handling
+    - goconst # Check for repeated strings that could be constants
+    - gosmopolitan # Check for non-portable code
 
-linters-settings:
+  settings:
-  gofmt:
+    misspell:
-    rewrite-rules:
+      locale: UK
-      - pattern: 'interface{}'
-        replacement: 'any'
-      - pattern: 'a[b:len(a)]'
-        replacement: 'a[b:]'
 
-  misspell:
+    errcheck:
-    locale: UK
+      check-type-assertions: true
+      check-blank: true
+      exclude-functions:
+        - fmt.Fprintf
+        - fmt.Fprintln
+        - fmt.Printf
+        - fmt.Println
+        - fmt.Errorf
 
-  errcheck:
+    revive:
-    check-type-assertions: true
+      severity: warning
+      rules:
+        # Code quality and style
+        - name: exported
+          arguments:
+            - 'checkPrivateReceivers'
+            - 'sayRepetitiveInsteadOfStutters'
+        - name: var-naming
+        - name: package-comments
+        - name: range-val-in-closure
+        - name: time-naming
+        - name: context-as-argument
+        - name: context-keys-type
+        - name: dot-imports
+        - name: empty-block
+        - name: error-return
+        - name: error-strings
+        - name: error-naming
+        - name: if-return
+        - name: increment-decrement
+        - name: indent-error-flow
+        - name: receiver-naming
+        - name: redefines-builtin-id
+        - name: superfluous-else
+        - name: unexported-return
+        - name: unreachable-code
+        - name: unused-parameter
+        - name: var-declaration
+        - name: blank-imports
+        - name: range
+
+        # Disabled rules (can be enabled if needed)
+        # - name: line-length-limit
+        #   arguments: [120]
+        # - name: function-length
+        #   arguments: [50, 0]
+        # - name: cyclomatic
+        #   arguments: [10]
+
+    gosec:
+      excludes:
+        - G104 # Duplicated errcheck checks
+        - G115 # integer overflow conversion int -> uint32
+
+  exclusions:
+    warn-unused: false
+    rules:
+      # Exclude specific linters for test files
+      - path: _test\.go
+        linters:
+          - gocyclo
+          - errcheck
+          - dupl
+          - gosec
+          - misspell
+          - golines
+
+    paths:
+      - vendor
+
+# Formatters configuration
+formatters:
+  # Enable specific formatters
+  enable:
+    - gofumpt # Stricter gofmt alternative
+    - goimports # Organizes imports
+    - gci # Controls import order/grouping
+    - golines # Enforces line length
+
+  # Formatter-specific settings
+  settings:
+    goimports:
+      local-prefixes: [github.com/onyx-and-iris/gobs-cli]
+
+    gci:
+      # Define import sections order
+      sections:
+        - standard # Standard library
+        - default # Everything else
+        - prefix(github.com/onyx-and-iris/gobs-cli) # Current module
+
+    gofumpt:
+      extra-rules: true # Enable additional formatting rules
+
+  exclusions:
+    warn-unused: true
+
+    paths:
+      - vendor
 
 issues:
-  max-same-issues: 0
+  # Limit the number of same issues reported to avoid spam
-  max-issues-per-linter: 0
+  max-same-issues: 50
-  exclude-use-default: false
+
-  exclude:
+  # Limit the number of issues per linter to keep output manageable
-    # gosec: Duplicated errcheck checks
+  max-issues-per-linter: 100
-    - G104
-  exclude-files:
-    # Exclude vendor directory
-    - main_test.go

filter.go

@@ -44,7 +44,11 @@ func (cmd *FilterListCmd) Run(ctx *context) error {
 	}
 
 	if len(sourceFilters.Filters) == 0 {
-		fmt.Fprintf(ctx.Out, "No filters found for source %s.\n", ctx.Style.Highlight(cmd.SourceName))
+		fmt.Fprintf(
+			ctx.Out,
+			"No filters found for source %s.\n",
+			ctx.Style.Highlight(cmd.SourceName),
+		)
 		return nil
 	}
 

group.go

@@ -66,7 +66,11 @@ func (cmd *GroupListCmd) Run(ctx *context) error {
 	var found bool
 	for _, item := range resp.SceneItems {
 		if item.IsGroup {
-			t.Row(fmt.Sprintf("%d", item.SceneItemID), item.SourceName, getEnabledMark(item.SceneItemEnabled))
+			t.Row(
+				fmt.Sprintf("%d", item.SceneItemID),
+				item.SourceName,
+				getEnabledMark(item.SceneItemEnabled),
+			)
 			found = true
 		}
 	}
@@ -97,10 +101,12 @@ func (cmd *GroupShowCmd) Run(ctx *context) error {
 	var found bool
 	for _, item := range resp.SceneItems {
 		if item.IsGroup && item.SourceName == cmd.GroupName {
-			_, err := ctx.Client.SceneItems.SetSceneItemEnabled(sceneitems.NewSetSceneItemEnabledParams().
+			_, err := ctx.Client.SceneItems.SetSceneItemEnabled(
-				WithSceneName(cmd.SceneName).
+				sceneitems.NewSetSceneItemEnabledParams().
-				WithSceneItemId(item.SceneItemID).
+					WithSceneName(cmd.SceneName).
-				WithSceneItemEnabled(true))
+					WithSceneItemId(item.SceneItemID).
+					WithSceneItemEnabled(true),
+			)
 			if err != nil {
 				return fmt.Errorf("failed to set scene item enabled: %w", err)
 			}
@@ -136,10 +142,12 @@ func (cmd *GroupHideCmd) Run(ctx *context) error {
 	var found bool
 	for _, item := range resp.SceneItems {
 		if item.IsGroup && item.SourceName == cmd.GroupName {
-			_, err := ctx.Client.SceneItems.SetSceneItemEnabled(sceneitems.NewSetSceneItemEnabledParams().
+			_, err := ctx.Client.SceneItems.SetSceneItemEnabled(
-				WithSceneName(cmd.SceneName).
+				sceneitems.NewSetSceneItemEnabledParams().
-				WithSceneItemId(item.SceneItemID).
+					WithSceneName(cmd.SceneName).
-				WithSceneItemEnabled(false))
+					WithSceneItemId(item.SceneItemID).
+					WithSceneItemEnabled(false),
+			)
 			if err != nil {
 				return fmt.Errorf("failed to set scene item enabled: %w", err)
 			}
@@ -176,17 +184,23 @@ func (cmd *GroupToggleCmd) Run(ctx *context) error {
 	for _, item := range resp.SceneItems {
 		if item.IsGroup && item.SourceName == cmd.GroupName {
 			newState := !item.SceneItemEnabled
-			_, err := ctx.Client.SceneItems.SetSceneItemEnabled(sceneitems.NewSetSceneItemEnabledParams().
+			_, err := ctx.Client.SceneItems.SetSceneItemEnabled(
-				WithSceneName(cmd.SceneName).
+				sceneitems.NewSetSceneItemEnabledParams().
-				WithSceneItemId(item.SceneItemID).
+					WithSceneName(cmd.SceneName).
-				WithSceneItemEnabled(newState))
+					WithSceneItemId(item.SceneItemID).
+					WithSceneItemEnabled(newState),
+			)
 			if err != nil {
 				return fmt.Errorf("failed to set scene item enabled: %w", err)
 			}
 			if newState {
 				fmt.Fprintf(ctx.Out, "Group %s is now shown.\n", ctx.Style.Highlight(cmd.GroupName))
 			} else {
-				fmt.Fprintf(ctx.Out, "Group %s is now hidden.\n", ctx.Style.Highlight(cmd.GroupName))
+				fmt.Fprintf(
+					ctx.Out,
+					"Group %s is now hidden.\n",
+					ctx.Style.Highlight(cmd.GroupName),
+				)
 			}
 			found = true
 			break
@@ -226,5 +240,9 @@ func (cmd *GroupStatusCmd) Run(ctx *context) error {
 			return nil
 		}
 	}
-	return fmt.Errorf("group %s not found in scene %s", ctx.Style.Error(cmd.GroupName), ctx.Style.Error(cmd.SceneName))
+	return fmt.Errorf(
+		"group %s not found in scene %s",
+		ctx.Style.Error(cmd.GroupName),
+		ctx.Style.Error(cmd.SceneName),
+	)
 }

input.go

@@ -50,8 +50,15 @@ func (cmd *InputCreateCmd) Run(ctx *context) error {
 		return err
 	}
 
-	fmt.Fprintf(ctx.Out, "Created input: %s (%s) in scene %s\n",
+	fmt.Fprintf(
-		ctx.Style.Highlight(cmd.Name), cmd.Kind, ctx.Style.Highlight(currentScene.CurrentProgramSceneName))
+		ctx.Out,
+		"Created input: %s (%s) in scene %s\n",
+		ctx.Style.Highlight(
+			cmd.Name,
+		),
+		cmd.Kind,
+		ctx.Style.Highlight(currentScene.CurrentProgramSceneName),
+	)
 	return nil
 }
 
@@ -166,7 +173,12 @@ func (cmd *InputListCmd) Run(ctx *context) error {
 
 		if !added && (!cmd.Input && !cmd.Output && !cmd.Colour && !cmd.Ffmpeg && !cmd.Vlc) {
 			if cmd.UUID {
-				t.Row(input.InputName, snakeCaseToTitleCase(input.InputKind), muteMark, input.InputUuid)
+				t.Row(
+					input.InputName,
+					snakeCaseToTitleCase(input.InputKind),
+					muteMark,
+					input.InputUuid,
+				)
 			} else {
 				t.Row(input.InputName, snakeCaseToTitleCase(input.InputKind), muteMark)
 			}
@@ -193,8 +205,7 @@ func (cmd *InputListKindsCmd) Run(ctx *context) error {
 	t.Headers("Kind")
 	t.StyleFunc(func(row, col int) lipgloss.Style {
 		style := lipgloss.NewStyle().Padding(0, 3)
-		switch col {
+		if col == 0 {
-		case 0:
 			style = style.Align(lipgloss.Left)
 		}
 		switch {
@@ -384,8 +395,7 @@ func (cmd *InputShowCmd) Run(ctx *context) error {
 			BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border))
 		t.StyleFunc(func(row, col int) lipgloss.Style {
 			style := lipgloss.NewStyle().Padding(0, 3)
-			switch col {
+			if col == 0 {
-			case 0:
 				style = style.Align(lipgloss.Left)
 			}
 			switch {

main.go

@@ -105,7 +105,11 @@ func main() {
 		&cli,
 		kong.Name("gobs-cli"),
 		kong.Description("A command line tool to interact with OBS Websocket."),
-		kong.Configuration(kongdotenv.ENVFileReader, ".env", filepath.Join(userConfigDir, "gobs-cli", "config.env")),
+		kong.Configuration(
+			kongdotenv.ENVFileReader,
+			".env",
+			filepath.Join(userConfigDir, "gobs-cli", "config.env"),
+		),
 		kong.UsageOnError(),
 		kong.ConfigureHelp(kong.HelpOptions{
 			Compact: true,
@@ -121,7 +125,8 @@ func main() {
 				}
 				return version
 			}(),
-		})
+		},
+	)
 
 	ctx.FatalIfErrorf(run(ctx, cli.ObsConfig, cli.StyleConfig))
 }
@@ -144,7 +149,7 @@ func run(ctx *kong.Context, obsCfg ObsConfig, styleCfg StyleConfig) error {
 			return fmt.Errorf("failed to disconnect from OBS: %w", err)
 		}
 		return nil
-	}()
+	}() // nolint: errcheck
 
 	ctx.Bind(newContext(client, os.Stdout, styleCfg))
 

main_test.go

@@ -43,7 +43,6 @@ func TestMain(m *testing.M) {
 	if err != nil {
 		os.Exit(1)
 	}
-	defer client.Disconnect()
 
 	setup(client)
 
@@ -51,11 +50,13 @@ func TestMain(m *testing.M) {
 	exitCode := m.Run()
 
 	teardown(client)
+	client.Disconnect()
 
 	// Exit with the appropriate code
 	os.Exit(exitCode)
 }
 
+// nolint: misspell
 func setup(client *goobs.Client) {
 	client.Config.SetStreamServiceSettings(config.NewSetStreamServiceSettingsParams().
 		WithStreamServiceType("rtmp_common").

profile.go

@@ -94,7 +94,9 @@ func (cmd *ProfileSwitchCmd) Run(ctx *context) error {
 		return fmt.Errorf("already using profile %s", ctx.Style.Error(cmd.Name))
 	}
 
-	_, err = ctx.Client.Config.SetCurrentProfile(config.NewSetCurrentProfileParams().WithProfileName(cmd.Name))
+	_, err = ctx.Client.Config.SetCurrentProfile(
+		config.NewSetCurrentProfileParams().WithProfileName(cmd.Name),
+	)
 	if err != nil {
 		return fmt.Errorf("failed to switch to profile %s: %w", ctx.Style.Error(cmd.Name), err)
 	}
@@ -125,7 +127,9 @@ func (cmd *ProfileCreateCmd) Run(ctx *context) error {
 		return fmt.Errorf("profile %s already exists", ctx.Style.Error(cmd.Name))
 	}
 
-	_, err = ctx.Client.Config.CreateProfile(config.NewCreateProfileParams().WithProfileName(cmd.Name))
+	_, err = ctx.Client.Config.CreateProfile(
+		config.NewCreateProfileParams().WithProfileName(cmd.Name),
+	)
 	if err != nil {
 		return fmt.Errorf("failed to create profile %s: %w", ctx.Style.Error(cmd.Name), err)
 	}
@@ -157,7 +161,9 @@ func (cmd *ProfileRemoveCmd) Run(ctx *context) error {
 		return fmt.Errorf("cannot delete current profile %s", ctx.Style.Error(cmd.Name))
 	}
 
-	_, err = ctx.Client.Config.RemoveProfile(config.NewRemoveProfileParams().WithProfileName(cmd.Name))
+	_, err = ctx.Client.Config.RemoveProfile(
+		config.NewRemoveProfileParams().WithProfileName(cmd.Name),
+	)
 	if err != nil {
 		return fmt.Errorf("failed to delete profile %s: %w", ctx.Style.Error(cmd.Name), err)
 	}

projector.go

@@ -97,9 +97,12 @@ func (cmd *ProjectorOpenCmd) Run(ctx *context) error {
 		)
 	}
 
-	ctx.Client.Ui.OpenSourceProjector(ui.NewOpenSourceProjectorParams().
+	_, err = ctx.Client.Ui.OpenSourceProjector(ui.NewOpenSourceProjectorParams().
 		WithSourceName(cmd.SourceName).
 		WithMonitorIndex(cmd.MonitorIndex))
+	if err != nil {
+		return fmt.Errorf("failed to open projector: %w", err)
+	}
 
 	fmt.Fprintf(
 		ctx.Out,

record.go

@@ -66,7 +66,10 @@ func (cmd *RecordStopCmd) Run(ctx *context) error {
 	fmt.Fprintf(
 		ctx.Out,
 		"%s",
-		fmt.Sprintf("Recording stopped successfully. Output file: %s\n", ctx.Style.Highlight(resp.OutputPath)),
+		fmt.Sprintf(
+			"Recording stopped successfully. Output file: %s\n",
+			ctx.Style.Highlight(resp.OutputPath),
+		),
 	)
 	return nil
 }
@@ -176,7 +179,11 @@ func (cmd *RecordDirectoryCmd) Run(ctx *context) error {
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Current recording directory: %s\n", ctx.Style.Highlight(resp.RecordDirectory))
+		fmt.Fprintf(
+			ctx.Out,
+			"Current recording directory: %s\n",
+			ctx.Style.Highlight(resp.RecordDirectory),
+		)
 		return nil
 	}
 
@@ -187,7 +194,11 @@ func (cmd *RecordDirectoryCmd) Run(ctx *context) error {
 		return err
 	}
 
-	fmt.Fprintf(ctx.Out, "Recording directory set to: %s\n", ctx.Style.Highlight(cmd.RecordDirectory))
+	fmt.Fprintf(
+		ctx.Out,
+		"Recording directory set to: %s\n",
+		ctx.Style.Highlight(cmd.RecordDirectory),
+	)
 	return nil
 }
 

record_test.go

@@ -1,3 +1,4 @@
+// nolint: goconst
 package main
 
 import (

scenecollection.go

@@ -32,8 +32,7 @@ func (cmd *SceneCollectionListCmd) Run(ctx *context) error {
 		Headers("Scene Collection Name").
 		StyleFunc(func(row, col int) lipgloss.Style {
 			style := lipgloss.NewStyle().Padding(0, 3)
-			switch col {
+			if col == 0 {
-			case 0:
 				style = style.Align(lipgloss.Left)
 			}
 			switch {
@@ -89,7 +88,11 @@ func (cmd *SceneCollectionSwitchCmd) Run(ctx *context) error {
 		config.NewSetCurrentSceneCollectionParams().WithSceneCollectionName(cmd.Name),
 	)
 	if err != nil {
-		return fmt.Errorf("failed to switch scene collection %s: %w", ctx.Style.Error(cmd.Name), err)
+		return fmt.Errorf(
+			"failed to switch scene collection %s: %w",
+			ctx.Style.Error(cmd.Name),
+			err,
+		)
 	}
 
 	fmt.Fprintf(ctx.Out, "Switched to scene collection: %s\n", ctx.Style.Highlight(cmd.Name))
@@ -108,7 +111,11 @@ func (cmd *SceneCollectionCreateCmd) Run(ctx *context) error {
 		config.NewCreateSceneCollectionParams().WithSceneCollectionName(cmd.Name),
 	)
 	if err != nil {
-		return fmt.Errorf("failed to create scene collection %s: %w", ctx.Style.Error(cmd.Name), err)
+		return fmt.Errorf(
+			"failed to create scene collection %s: %w",
+			ctx.Style.Error(cmd.Name),
+			err,
+		)
 	}
 
 	fmt.Fprintf(ctx.Out, "Created scene collection: %s\n", ctx.Style.Highlight(cmd.Name))

sceneitem.go

@@ -44,7 +44,11 @@ func (cmd *SceneItemListCmd) Run(ctx *context) error {
 	}
 
 	if len(resp.SceneItems) == 0 {
-		fmt.Fprintf(ctx.Out, "No scene items found in scene %s.\n", ctx.Style.Highlight(cmd.SceneName))
+		fmt.Fprintf(
+			ctx.Out,
+			"No scene items found in scene %s.\n",
+			ctx.Style.Highlight(cmd.SceneName),
+		)
 		return nil
 	}
 
@@ -86,8 +90,10 @@ func (cmd *SceneItemListCmd) Run(ctx *context) error {
 
 	for _, item := range resp.SceneItems {
 		if item.IsGroup {
-			resp, err := ctx.Client.SceneItems.GetGroupSceneItemList(sceneitems.NewGetGroupSceneItemListParams().
+			resp, err := ctx.Client.SceneItems.GetGroupSceneItemList(
-				WithSceneName(item.SourceName))
+				sceneitems.NewGetGroupSceneItemListParams().
+					WithSceneName(item.SourceName),
+			)
 			if err != nil {
 				return fmt.Errorf(
 					"failed to get group scene item list for group %s: %w",
@@ -123,7 +129,12 @@ func (cmd *SceneItemListCmd) Run(ctx *context) error {
 				t.Row(fmt.Sprintf("%d", item.SceneItemID), item.SourceName, "",
 					getEnabledMark(item.SceneItemEnabled), item.SourceUuid)
 			} else {
-				t.Row(fmt.Sprintf("%d", item.SceneItemID), item.SourceName, "", getEnabledMark(item.SceneItemEnabled))
+				t.Row(
+					fmt.Sprintf("%d", item.SceneItemID),
+					item.SourceName,
+					"",
+					getEnabledMark(item.SceneItemEnabled),
+				)
 			}
 		}
 	}
@@ -139,8 +150,10 @@ func getSceneNameAndItemID(
 	group string,
 ) (string, int, error) {
 	if group != "" {
-		resp, err := ctx.Client.SceneItems.GetGroupSceneItemList(sceneitems.NewGetGroupSceneItemListParams().
+		resp, err := ctx.Client.SceneItems.GetGroupSceneItemList(
-			WithSceneName(group))
+			sceneitems.NewGetGroupSceneItemListParams().
+				WithSceneName(group),
+		)
 		if err != nil {
 			return "", 0, err
 		}
@@ -149,7 +162,11 @@ func getSceneNameAndItemID(
 				return group, int(item.SceneItemID), nil
 			}
 		}
-		return "", 0, fmt.Errorf("item %s not found in scene %s", ctx.Style.Error(itemName), ctx.Style.Error(sceneName))
+		return "", 0, fmt.Errorf(
+			"item %s not found in scene %s",
+			ctx.Style.Error(itemName),
+			ctx.Style.Error(sceneName),
+		)
 	}
 
 	itemID, err := ctx.Client.SceneItems.GetSceneItemId(sceneitems.NewGetSceneItemIdParams().
@@ -180,7 +197,12 @@ type SceneItemShowCmd struct {
 
 // Run executes the command to show a scene item.
 func (cmd *SceneItemShowCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx, cmd.SceneName, cmd.ItemName, cmd.Group)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(
+		ctx,
+		cmd.SceneName,
+		cmd.ItemName,
+		cmd.Group,
+	)
 	if err != nil {
 		return err
 	}
@@ -201,7 +223,12 @@ func (cmd *SceneItemShowCmd) Run(ctx *context) error {
 			ctx.Style.Highlight(cmd.Group),
 		)
 	} else {
-		fmt.Fprintf(ctx.Out, "Scene item %s in scene %s is now visible.\n", ctx.Style.Highlight(cmd.ItemName), ctx.Style.Highlight(cmd.SceneName))
+		fmt.Fprintf(
+			ctx.Out,
+			"Scene item %s in scene %s is now visible.\n",
+			ctx.Style.Highlight(cmd.ItemName),
+			ctx.Style.Highlight(cmd.SceneName),
+		)
 	}
 
 	return nil
@@ -217,7 +244,12 @@ type SceneItemHideCmd struct {
 
 // Run executes the command to hide a scene item.
 func (cmd *SceneItemHideCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx, cmd.SceneName, cmd.ItemName, cmd.Group)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(
+		ctx,
+		cmd.SceneName,
+		cmd.ItemName,
+		cmd.Group,
+	)
 	if err != nil {
 		return err
 	}
@@ -238,7 +270,12 @@ func (cmd *SceneItemHideCmd) Run(ctx *context) error {
 			ctx.Style.Highlight(cmd.Group),
 		)
 	} else {
-		fmt.Fprintf(ctx.Out, "Scene item %s in scene %s is now hidden.\n", ctx.Style.Highlight(cmd.ItemName), ctx.Style.Highlight(cmd.SceneName))
+		fmt.Fprintf(
+			ctx.Out,
+			"Scene item %s in scene %s is now hidden.\n",
+			ctx.Style.Highlight(cmd.ItemName),
+			ctx.Style.Highlight(cmd.SceneName),
+		)
 	}
 
 	return nil
@@ -265,7 +302,12 @@ type SceneItemToggleCmd struct {
 
 // Run executes the command to toggle the visibility of a scene item.
 func (cmd *SceneItemToggleCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx, cmd.SceneName, cmd.ItemName, cmd.Group)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(
+		ctx,
+		cmd.SceneName,
+		cmd.ItemName,
+		cmd.Group,
+	)
 	if err != nil {
 		return err
 	}
@@ -291,7 +333,12 @@ func (cmd *SceneItemToggleCmd) Run(ctx *context) error {
 			ctx.Style.Highlight(cmd.SceneName),
 		)
 	} else {
-		fmt.Fprintf(ctx.Out, "Scene item %s in scene %s is now visible.\n", ctx.Style.Highlight(cmd.ItemName), ctx.Style.Highlight(cmd.SceneName))
+		fmt.Fprintf(
+			ctx.Out,
+			"Scene item %s in scene %s is now visible.\n",
+			ctx.Style.Highlight(cmd.ItemName),
+			ctx.Style.Highlight(cmd.SceneName),
+		)
 	}
 
 	return nil
@@ -307,7 +354,12 @@ type SceneItemVisibleCmd struct {
 
 // Run executes the command to check the visibility of a scene item.
 func (cmd *SceneItemVisibleCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx, cmd.SceneName, cmd.ItemName, cmd.Group)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(
+		ctx,
+		cmd.SceneName,
+		cmd.ItemName,
+		cmd.Group,
+	)
 	if err != nil {
 		return err
 	}
@@ -325,7 +377,12 @@ func (cmd *SceneItemVisibleCmd) Run(ctx *context) error {
 			ctx.Style.Highlight(cmd.SceneName),
 		)
 	} else {
-		fmt.Fprintf(ctx.Out, "Scene item %s in scene %s is hidden.\n", ctx.Style.Highlight(cmd.ItemName), ctx.Style.Highlight(cmd.SceneName))
+		fmt.Fprintf(
+			ctx.Out,
+			"Scene item %s in scene %s is hidden.\n",
+			ctx.Style.Highlight(cmd.ItemName),
+			ctx.Style.Highlight(cmd.SceneName),
+		)
 	}
 	return nil
 }
@@ -356,15 +413,22 @@ type SceneItemTransformCmd struct {
 
 // Run executes the command to transform a scene item.
 func (cmd *SceneItemTransformCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx, cmd.SceneName, cmd.ItemName, cmd.Group)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(
+		ctx,
+		cmd.SceneName,
+		cmd.ItemName,
+		cmd.Group,
+	)
 	if err != nil {
 		return err
 	}
 
 	// Get the current transform of the scene item
-	resp, err := ctx.Client.SceneItems.GetSceneItemTransform(sceneitems.NewGetSceneItemTransformParams().
+	resp, err := ctx.Client.SceneItems.GetSceneItemTransform(
-		WithSceneName(sceneName).
+		sceneitems.NewGetSceneItemTransformParams().
-		WithSceneItemId(sceneItemID))
+			WithSceneName(sceneName).
+			WithSceneItemId(sceneItemID),
+	)
 	if err != nil {
 		return err
 	}
@@ -420,10 +484,12 @@ func (cmd *SceneItemTransformCmd) Run(ctx *context) error {
 		transform.ScaleY = cmd.ScaleY
 	}
 
-	_, err = ctx.Client.SceneItems.SetSceneItemTransform(sceneitems.NewSetSceneItemTransformParams().
+	_, err = ctx.Client.SceneItems.SetSceneItemTransform(
-		WithSceneName(sceneName).
+		sceneitems.NewSetSceneItemTransformParams().
-		WithSceneItemId(sceneItemID).
+			WithSceneName(sceneName).
-		WithSceneItemTransform(transform))
+			WithSceneItemId(sceneItemID).
+			WithSceneItemTransform(transform),
+	)
 	if err != nil {
 		return err
 	}
@@ -436,7 +502,12 @@ func (cmd *SceneItemTransformCmd) Run(ctx *context) error {
 			ctx.Style.Highlight(cmd.Group),
 		)
 	} else {
-		fmt.Fprintf(ctx.Out, "Scene item %s in scene %s transformed.\n", ctx.Style.Highlight(cmd.ItemName), ctx.Style.Highlight(cmd.SceneName))
+		fmt.Fprintf(
+			ctx.Out,
+			"Scene item %s in scene %s transformed.\n",
+			ctx.Style.Highlight(cmd.ItemName),
+			ctx.Style.Highlight(cmd.SceneName),
+		)
 	}
 
 	return nil

stream.go

@@ -91,7 +91,12 @@ func (cmd *StreamStatusCmd) Run(ctx *context) error {
 		minutes := int(seconds / 60)
 		secondsInt := int(seconds) % 60
 		if minutes > 0 {
-			fmt.Fprintf(ctx.Out, "Output duration: %d minutes and %d seconds\n", minutes, secondsInt)
+			fmt.Fprintf(
+				ctx.Out,
+				"Output duration: %d minutes and %d seconds\n",
+				minutes,
+				secondsInt,
+			)
 		} else {
 			fmt.Fprintf(ctx.Out, "Output duration: %d seconds\n", secondsInt)
 		}

studiomode.go

@@ -19,7 +19,9 @@ type StudioModeEnableCmd struct{} // size = 0x0
 
 // Run executes the command to enable studio mode.
 func (cmd *StudioModeEnableCmd) Run(ctx *context) error {
-	_, err := ctx.Client.Ui.SetStudioModeEnabled(ui.NewSetStudioModeEnabledParams().WithStudioModeEnabled(true))
+	_, err := ctx.Client.Ui.SetStudioModeEnabled(
+		ui.NewSetStudioModeEnabledParams().WithStudioModeEnabled(true),
+	)
 	if err != nil {
 		return fmt.Errorf("failed to enable studio mode: %w", err)
 	}
@@ -33,7 +35,9 @@ type StudioModeDisableCmd struct{} // size = 0x0
 
 // Run executes the command to disable studio mode.
 func (cmd *StudioModeDisableCmd) Run(ctx *context) error {
-	_, err := ctx.Client.Ui.SetStudioModeEnabled(ui.NewSetStudioModeEnabledParams().WithStudioModeEnabled(false))
+	_, err := ctx.Client.Ui.SetStudioModeEnabled(
+		ui.NewSetStudioModeEnabledParams().WithStudioModeEnabled(false),
+	)
 	if err != nil {
 		return fmt.Errorf("failed to disable studio mode: %w", err)
 	}
@@ -53,7 +57,9 @@ func (cmd *StudioModeToggleCmd) Run(ctx *context) error {
 	}
 
 	newStatus := !status.StudioModeEnabled
-	_, err = ctx.Client.Ui.SetStudioModeEnabled(ui.NewSetStudioModeEnabledParams().WithStudioModeEnabled(newStatus))
+	_, err = ctx.Client.Ui.SetStudioModeEnabled(
+		ui.NewSetStudioModeEnabledParams().WithStudioModeEnabled(newStatus),
+	)
 	if err != nil {
 		return fmt.Errorf("failed to toggle studio mode: %w", err)
 	}

text.go

@@ -80,6 +80,11 @@ func (cmd *TextUpdateCmd) Run(ctx *context) error {
 	if cmd.NewText == "" {
 		cmd.NewText = "(empty)"
 	}
-	fmt.Fprintf(ctx.Out, "Updated text for source %s to: %s\n", ctx.Style.Highlight(cmd.InputName), cmd.NewText)
+	fmt.Fprintf(
+		ctx.Out,
+		"Updated text for source %s to: %s\n",
+		ctx.Style.Highlight(cmd.InputName),
+		cmd.NewText,
+	)
 	return nil
 }