chore: attempt to fix merge conflicts

Author: yjp20

pkg/cmd/auth.go

@@ -71,10 +71,9 @@ func authenticate(ctx context.Context, cmd *cli.Command, forceAuthentication boo
 	}
 
 	group := console.Info("To authenticate, visit the verification URL")
-	cc := getAPICommandContext(cmd)
-	clientID := cmd.String("client-id")
+	client := stainless.NewClient(getDefaultRequestOptions(cmd)...)
 	scope := "*"
-	authResult, err := startDeviceFlow(ctx, cmd, cc.client, clientID, scope, group)
+	authResult, err := startDeviceFlow(ctx, cmd, client, cmd.String("client-id"), scope, group)
 	if err != nil {
 		return err
 	}

pkg/cmd/build.go

@@ -17,82 +17,49 @@ import (
 	"github.com/stainless-api/stainless-api-go/option"
 
 	"github.com/tidwall/gjson"
-	"github.com/tidwall/sjson"
 	"github.com/urfave/cli/v3"
 )
 
 // parseTargetPaths processes target flags to extract target:path syntax with workspace config
 // Returns a map of target names to their custom paths
-func parseTargetPaths(workspaceConfig WorkspaceConfig) map[stainless.Target]string {
-	targetPaths := make(map[stainless.Target]string)
+func parseTargetPaths(workspaceConfig WorkspaceConfig, targetsSlice []string) (downloadPaths map[stainless.Target]string, targets []stainless.Target) {
+	downloadPaths = make(map[stainless.Target]string)
 
 	// Check workspace configuration for target paths if loaded
 	for targetName, targetConfig := range workspaceConfig.Targets {
 		if targetConfig.OutputPath != "" {
-			targetPaths[stainless.Target(targetName)] = targetConfig.OutputPath
+			downloadPaths[stainless.Target(targetName)] = targetConfig.OutputPath
 		}
 	}
 
-	// Get the current JSON body with all mutations applied
-	body, _, _, err := jsonflag.ApplyMutations([]byte("{}"), []byte("{}"), []byte("{}"))
-	if err != nil {
-		return targetPaths // If we can't parse, return map with workspace paths
-	}
-
-	// Check if there are any targets in the body
-	targetsResult := gjson.GetBytes(body, "targets")
-	if !targetsResult.Exists() {
-		return targetPaths
-	}
-
-	// Process the targets array
-	var cleanTargets []string
-	for _, targetResult := range targetsResult.Array() {
-		target := targetResult.String()
+	// Process the targets array from the CLI
+	for _, target := range targetsSlice {
 		cleanTarget, path := processSingleTarget(target)
-		cleanTargets = append(cleanTargets, cleanTarget)
+		targets = append(targets, cleanTarget)
 		if path != "" {
 			// Command line target:path overrides workspace configuration
-			targetPaths[stainless.Target(cleanTarget)] = path
+			downloadPaths[stainless.Target(cleanTarget)] = path
 		}
 	}
 
-	// Update the JSON body with cleaned targets
-	if len(cleanTargets) > 0 {
-		body, err = sjson.SetBytes(body, "targets", cleanTargets)
-		if err != nil {
-			return targetPaths
-		}
-
-		// Clear mutations and re-apply the cleaned JSON
-		jsonflag.ClearMutations()
-
-		// Re-register the cleaned body
-		bodyObj := gjson.ParseBytes(body)
-		bodyObj.ForEach(func(key, value gjson.Result) bool {
-			jsonflag.Mutate(jsonflag.Body, key.String(), value.Value())
-			return true
-		})
-	}
-
-	return targetPaths
+	return downloadPaths, targets
 }
 
 // processSingleTarget extracts path from target:path and returns clean target name and path
-func processSingleTarget(target string) (string, string) {
+func processSingleTarget(target string) (stainless.Target, string) {
 	target = strings.TrimSpace(target)
 	if !strings.Contains(target, ":") {
-		return target, ""
+		return stainless.Target(target), ""
 	}
 
 	parts := strings.SplitN(target, ":", 2)
 	if len(parts) != 2 {
-		return target, ""
+		return stainless.Target(target), ""
 	}
 
 	targetName := strings.TrimSpace(parts[0])
 	targetPath := strings.TrimSpace(parts[1])
-	return targetName, targetPath
+	return stainless.Target(targetName), targetPath
 }
 
 var buildsCreate = cli.Command{
@@ -133,16 +100,6 @@ var buildsCreate = cli.Command{
 			Name:  "target",
 			Usage: "Optional list of SDK targets to build. If not specified, all configured\ntargets will be built.",
 		},
-		&jsonflag.JSONStringFlag{
-			Name: "target",
-			Config: jsonflag.JSONConfig{
-				Kind: jsonflag.Body,
-				Path: "targets.-1",
-			},
-			Hidden: true,
-		},
-		&jsonflag.JSONStringFlag{,
-		},
 	},
 	Action:          handleBuildsCreate,
 	HideHelpCommand: true,
@@ -176,37 +133,50 @@ var buildsCompare = cli.Command{
 
 func handleBuildsCreate(ctx context.Context, cmd *cli.Command) error {
 	client := stainless.NewClient(getDefaultRequestOptions(cmd)...)
+
+	wc := WorkspaceConfig{}
+	if _, err := wc.Find(); err != nil {
+		console.Warn("%s", err)
+	}
+
 	unusedArgs := cmd.Args().Slice()
 	if len(unusedArgs) > 0 {
 		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
 	}
 
 	// Handle file flags by reading files and mutating JSON body
-	if err := applyFileFlag(cmd, "openapi-spec", "revision.openapi\\.yml.content"); err != nil {
+	if err := convertFileFlag(cmd, "openapi-spec", "revision.openapi\\.yml.content"); err != nil {
 		return err
 	}
-	if err := applyFileFlag(cmd, "stainless-config", "revision.openapi\\.stainless\\.yml.content"); err != nil {
+	if err := convertFileFlag(cmd, "stainless-config", "revision.openapi\\.stainless\\.yml.content"); err != nil {
 		return err
 	}
 
 	buildGroup := console.Info("Creating build...")
 	params := stainless.BuildNewParams{}
-	build, err := cc.client.Builds.New(
+	if err := unmarshalStdinWithFlags(cmd, map[string]string{
+		"targets": "targets",
+	}, &params); err != nil {
+		return err
+	}
+
+	downloadPaths, targets := parseTargetPaths(wc, cmd.StringSlice("target"))
+	params.Targets = targets
+
+	build, err := client.Builds.New(
 		ctx,
 		params,
-		option.WithMiddleware(cc.AsMiddleware()),
+		option.WithMiddleware(debugMiddleware(cmd.Bool("debug"))),
 	)
 	if err != nil {
 		return err
 	}
 
 	buildGroup.Property("build_id", build.ID)
 
-	downloadPaths := parseTargetPaths(cc.workspaceConfig)
-
 	if cmd.Bool("wait") {
 		console.Spacer()
-		model := tea.Model(buildCompletionModel{cbuild.NewModel(cc.client, ctx, *build, downloadPaths)})
+		model := tea.Model(buildCompletionModel{cbuild.NewModel(client, ctx, *build, downloadPaths)})
 		model, err = tea.NewProgram(model).Run()
 		if err != nil {
 			console.Warn(err.Error())

pkg/cmd/buildtargetoutput.go

@@ -6,8 +6,8 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/stainless-api/stainless-api-cli/pkg/console"
 	"github.com/stainless-api/stainless-api-cli/pkg/components/build"
+	"github.com/stainless-api/stainless-api-cli/pkg/console"
 	"github.com/stainless-api/stainless-api-go"
 	"github.com/stainless-api/stainless-api-go/option"
 	"github.com/tidwall/gjson"
@@ -59,7 +59,7 @@ func handleBuildsTargetOutputsRetrieve(ctx context.Context, cmd *cli.Command) er
 
 	buildID := cmd.String("build-id")
 	if buildID == "" {
-		latestBuild, err := getLatestBuild(ctx, cc.client, cmd.String("project"), cmd.String("branch"))
+		latestBuild, err := getLatestBuild(ctx, client, cmd.String("project"), cmd.String("branch"))
 		if err != nil {
 			return fmt.Errorf("failed to get latest build: %v", err)
 		}

pkg/cmd/configwatcher.go

@@ -11,12 +11,12 @@ import (
 
 type configChangedEvent struct{}
 
-func waitTillConfigChanges(ctx context.Context, cmd *cli.Command, cc *apiCommandContext) error {
-	openapiSpecPath := cc.workspaceConfig.OpenAPISpec
+func waitTillConfigChanges(ctx context.Context, cmd *cli.Command, wc WorkspaceConfig) error {
+	openapiSpecPath := wc.OpenAPISpec
 	if cmd.IsSet("openapi-spec") {
 		openapiSpecPath = cmd.String("openapi-spec")
 	}
-	stainlessConfigPath := cc.workspaceConfig.StainlessConfig
+	stainlessConfigPath := wc.StainlessConfig
 	if cmd.IsSet("stainless-config") {
 		stainlessConfigPath = cmd.String("stainless-config")
 	}

pkg/cmd/dev.go

@@ -70,7 +70,12 @@ func runPreview(ctx context.Context, cmd *cli.Command) error {
 		os.Stdout.Sync()
 	}
 
-	cc := getAPICommandContext(cmd)
+	client := stainless.NewClient(getDefaultRequestOptions(cmd)...)
+
+	wc := WorkspaceConfig{}
+	if _, err := wc.Find(); err != nil {
+		console.Warn("%s", err)
+	}
 
 	gitUser, err := getGitUsername()
 	if err != nil {
@@ -91,7 +96,7 @@ func runPreview(ctx context.Context, cmd *cli.Command) error {
 
 	// Phase 2: Language selection
 	var selectedTargets []string
-	targetInfos := getAvailableTargetInfo(ctx, cc.client, cmd.String("project"), cc.workspaceConfig)
+	targetInfos := getAvailableTargetInfo(ctx, client, cmd.String("project"), wc)
 	if cmd.IsSet("target") {
 		selectedTargets = cmd.StringSlice("target")
 		for _, target := range selectedTargets {
@@ -126,7 +131,7 @@ func runPreview(ctx context.Context, cmd *cli.Command) error {
 		}
 
 		// Start the build process
-		if err := runDevBuild(ctx, cc, cmd, selectedBranch, targets); err != nil {
+		if err := runDevBuild(ctx, client, wc, cmd, selectedBranch, targets); err != nil {
 			if errors.Is(err, build.ErrUserCancelled) {
 				return nil
 			}
@@ -202,12 +207,12 @@ func chooseSelectedTargets(targetInfos []TargetInfo) ([]string, error) {
 	return selectedTargets, nil
 }
 
-func runDevBuild(ctx context.Context, cc *apiCommandContext, cmd *cli.Command, branch string, languages []stainless.Target) error {
+func runDevBuild(ctx context.Context, client stainless.Client, wc WorkspaceConfig, cmd *cli.Command, branch string, languages []stainless.Target) error {
 	// Handle file flags by reading files and mutating JSON body
-	if err := applyFileFlag(cmd, "openapi-spec", "revision.openapi\\.yml.content"); err != nil {
+	if err := convertFileFlag(cmd, "openapi-spec", "revision.openapi\\.yml.content"); err != nil {
 		return err
 	}
-	if err := applyFileFlag(cmd, "stainless-config", "revision.openapi\\.stainless\\.yml.content"); err != nil {
+	if err := convertFileFlag(cmd, "stainless-config", "revision.openapi\\.stainless\\.yml.content"); err != nil {
 		return err
 	}
 
@@ -220,16 +225,20 @@ func runDevBuild(ctx context.Context, cc *apiCommandContext, cmd *cli.Command, b
 	}
 
 	downloads := make(map[stainless.Target]string)
-	for targetName, targetConfig := range cc.workspaceConfig.Targets {
+	for targetName, targetConfig := range wc.Targets {
 		downloads[stainless.Target(targetName)] = targetConfig.OutputPath
 	}
 
 	model := dev.NewModel(
-		cc.client,
+		client,
 		ctx,
 		branch,
 		func() (*stainless.Build, error) {
-			build, err := cc.client.Builds.New(ctx, buildReq, option.WithMiddleware(cc.AsMiddleware()))
+			build, err := client.Builds.New(
+				ctx,
+				buildReq,
+				option.WithMiddleware(debugMiddleware(cmd.Bool("debug"))),
+			)
 			if err != nil {
 				return nil, fmt.Errorf("failed to create build: %v", err)
 			}
@@ -291,16 +300,16 @@ type GenerateSpecParams struct {
 	} `json:"source"`
 }
 
-func getDiagnostics(ctx context.Context, cmd *cli.Command, cc *apiCommandContext) ([]stainless.BuildDiagnostic, error) {
+func getDiagnostics(ctx context.Context, cmd *cli.Command, client stainless.Client, wc WorkspaceConfig) ([]stainless.BuildDiagnostic, error) {
 	var specParams GenerateSpecParams
 	if cmd.IsSet("project") {
 		specParams.Project = cmd.String("project")
 	} else {
-		specParams.Project = cc.workspaceConfig.Project
+		specParams.Project = wc.Project
 	}
 	specParams.Source.Type = "upload"
 
-	configPath := cc.workspaceConfig.StainlessConfig
+	configPath := wc.StainlessConfig
 	if cmd.IsSet("stainless-config") {
 		configPath = cmd.String("stainless-config")
 	} else if configPath == "" {
@@ -313,7 +322,7 @@ func getDiagnostics(ctx context.Context, cmd *cli.Command, cc *apiCommandContext
 	}
 	specParams.Source.StainlessConfig = string(stainlessConfig)
 
-	oasPath := cc.workspaceConfig.OpenAPISpec
+	oasPath := wc.OpenAPISpec
 	if cmd.IsSet("openapi-spec") {
 		oasPath = cmd.String("openapi-spec")
 	} else if oasPath == "" {
@@ -327,7 +336,13 @@ func getDiagnostics(ctx context.Context, cmd *cli.Command, cc *apiCommandContext
 	specParams.Source.OpenAPISpec = string(openAPISpec)
 
 	var result []byte
-	err = cc.client.Post(ctx, "api/generate/spec", specParams, &result, option.WithMiddleware(cc.AsMiddleware()))
+	err = client.Post(
+		ctx,
+		"api/generate/spec",
+		specParams,
+		&result,
+		option.WithMiddleware(debugMiddleware(cmd.Bool("debug"))),
+	)
 	if err != nil {
 		return nil, err
 	}