feat: CLI exclusions, write confirmations, and job alias removal

- Parse x-exclude-from-cli OpenAPI extension; skip excluded ops in
  auto-generated command tree (superuser and legacy endpoints stay
  accessible via API but are hidden from CLI)
- Add --yes / -y persistent flag to bypass write confirmation prompt
- Prompt for confirmation on POST/PUT/DELETE/PATCH unless --yes or
  --dry-run (CI-friendly: use --yes in scripts)
- Add Excluded bool field to Operation struct
- Remove job-runs running/failed/completed alias subcommands; use
  job-runs list --status RUNNING|FAILED|COMPLETED instead
- Add CODEOWNERS assigning @wherobots/wbc-crew to all files

Author: ClayMav

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @wherobots/wbc-crew

internal/commands/builder.go

@@ -1,6 +1,7 @@
 package commands
 
 import (
+	"bufio"
 	"bytes"
 	"encoding/json"
 	"fmt"
@@ -23,6 +24,8 @@ var persistentFlagNames = map[string]struct{}{
 	"q":       {},
 	"dry-run": {},
 	"tree":    {},
+	"yes":     {},
+	"y":       {},
 }
 
 type parameterBinding struct {
@@ -75,6 +78,7 @@ func BuildRootCommand(cfg config.Config, runtimeSpec *spec.RuntimeSpec) *cobra.C
 	root.PersistentFlags().StringArrayVarP(&flags.Query, "query", "q", nil, "query pair (key=value), repeatable")
 	root.PersistentFlags().BoolVar(&flags.DryRun, "dry-run", false, "print curl equivalent without executing request")
 	root.PersistentFlags().BoolVar(&flags.Tree, "tree", false, "print available command tree")
+	root.PersistentFlags().BoolVarP(&flags.Yes, "yes", "y", false, "skip confirmation prompt (for CI/scripts)")
 
 	root.SetFlagErrorFunc(func(cmd *cobra.Command, err error) error {
 		return hints.Wrap(findOperationContext(operationByCommand, cmd), err)
@@ -95,6 +99,9 @@ func BuildRootCommand(cfg config.Config, runtimeSpec *spec.RuntimeSpec) *cobra.C
 	root.AddCommand(apiCmd)
 
 	for _, op := range runtimeSpec.Operations {
+		if op.Excluded {
+			continue
+		}
 		parent := ensureResourceHierarchy(apiCmd, resourceCommands, PathToResourceSegments(op.Path))
 		verb := uniqueVerbName(parent, ChooseVerb(op))
 		op.Verb = verb
@@ -142,6 +149,12 @@ func buildOperationCommand(
 			return printTree(cmd)
 		}
 
+		if !flags.DryRun && isWriteMethod(op.Method) && !flags.Yes {
+			if err := confirmAction(cmd, op); err != nil {
+				return err
+			}
+		}
+
 		parsedQuery, err := ParseQueryPairs(flags.Query)
 		if err != nil {
 			return hints.Wrap(op, err)
@@ -684,3 +697,22 @@ func buildOperationShort(op *spec.Operation) string {
 	}
 	return fmt.Sprintf("%s operation", strings.ToUpper(op.Method))
 }
+
+func isWriteMethod(method string) bool {
+	switch strings.ToUpper(method) {
+	case "POST", "PUT", "DELETE", "PATCH":
+		return true
+	}
+	return false
+}
+
+func confirmAction(cmd *cobra.Command, op *spec.Operation) error {
+	_, _ = fmt.Fprintf(cmd.ErrOrStderr(), "%s %s\nProceed? [y/N]: ", strings.ToUpper(op.Method), op.Path)
+	scanner := bufio.NewScanner(cmd.InOrStdin())
+	scanner.Scan()
+	answer := strings.TrimSpace(scanner.Text())
+	if strings.ToLower(answer) != "y" {
+		return fmt.Errorf("aborted")
+	}
+	return nil
+}

internal/commands/flags.go

@@ -10,6 +10,7 @@ type GlobalFlags struct {
 	Query    []string
 	DryRun   bool
 	Tree     bool
+	Yes      bool
 }
 
 type QueryPair struct {

internal/commands/jobs.go

@@ -74,9 +74,6 @@ func addJobsCustomCommands(root *cobra.Command, cfg config.Config, runtimeSpec *
 	jobsCmd.AddCommand(runner.newCreateCommand())
 	jobsCmd.AddCommand(runner.newLogsCommand())
 	jobsCmd.AddCommand(runner.newListCommand())
-	jobsCmd.AddCommand(runner.newRunningAliasCommand())
-	jobsCmd.AddCommand(runner.newFailedAliasCommand())
-	jobsCmd.AddCommand(runner.newCompletedAliasCommand())
 	if runner.getRunMetrics != nil {
 		jobsCmd.AddCommand(runner.newMetricsCommand())
 	}
@@ -730,84 +727,6 @@ func writeRunListTable(out io.Writer, body []byte) error {
 	return tw.Flush()
 }
 
-func (r *jobsRunner) newRunningAliasCommand() *cobra.Command {
-	var (
-		name   string
-		after  string
-		limit  int
-		region string
-		output string
-	)
-
-	cmd := &cobra.Command{
-		Use:           "running",
-		Short:         "Alias for job-runs list --status RUNNING",
-		SilenceUsage:  true,
-		SilenceErrors: true,
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			return r.executeList(cmd, []string{"RUNNING"}, name, after, limit, region, output)
-		},
-	}
-	cmd.Flags().StringVar(&name, "name", "", "filter by name pattern")
-	cmd.Flags().StringVar(&after, "after", "", "filter runs created after ISO timestamp")
-	cmd.Flags().IntVarP(&limit, "limit", "l", defaultListLimit, "max results")
-	cmd.Flags().StringVar(&region, "region", "", "filter by region")
-	cmd.Flags().StringVar(&output, "output", outputText, "output format: text|json")
-	return cmd
-}
-
-func (r *jobsRunner) newFailedAliasCommand() *cobra.Command {
-	var (
-		name   string
-		after  string
-		limit  int
-		region string
-		output string
-	)
-
-	cmd := &cobra.Command{
-		Use:           "failed",
-		Short:         "Alias for job-runs list --status FAILED",
-		SilenceUsage:  true,
-		SilenceErrors: true,
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			return r.executeList(cmd, []string{"FAILED"}, name, after, limit, region, output)
-		},
-	}
-	cmd.Flags().StringVar(&name, "name", "", "filter by name pattern")
-	cmd.Flags().StringVar(&after, "after", "", "filter runs created after ISO timestamp")
-	cmd.Flags().IntVarP(&limit, "limit", "l", defaultListLimit, "max results")
-	cmd.Flags().StringVar(&region, "region", "", "filter by region")
-	cmd.Flags().StringVar(&output, "output", outputText, "output format: text|json")
-	return cmd
-}
-
-func (r *jobsRunner) newCompletedAliasCommand() *cobra.Command {
-	var (
-		name   string
-		after  string
-		limit  int
-		region string
-		output string
-	)
-
-	cmd := &cobra.Command{
-		Use:           "completed",
-		Short:         "Alias for job-runs list --status COMPLETED",
-		SilenceUsage:  true,
-		SilenceErrors: true,
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			return r.executeList(cmd, []string{"COMPLETED"}, name, after, limit, region, output)
-		},
-	}
-	cmd.Flags().StringVar(&name, "name", "", "filter by name pattern")
-	cmd.Flags().StringVar(&after, "after", "", "filter runs created after ISO timestamp")
-	cmd.Flags().IntVarP(&limit, "limit", "l", defaultListLimit, "max results")
-	cmd.Flags().StringVar(&region, "region", "", "filter by region")
-	cmd.Flags().StringVar(&output, "output", outputText, "output format: text|json")
-	return cmd
-}
-
 func (r *jobsRunner) newMetricsCommand() *cobra.Command {
 	var output string
 

internal/spec/model.go

@@ -19,6 +19,7 @@ type Operation struct {
 	PathParamOrder []string
 	QueryParams    []Parameter
 	RequestBody    *RequestBodyInfo
+	Excluded       bool
 }
 
 type Parameter struct {

internal/spec/parser.go

@@ -67,6 +67,7 @@ func Parse(rawSpec []byte, openAPIURL string) (*RuntimeSpec, error) {
 				PathParamOrder: pathParamOrder,
 				QueryParams:    queryParams,
 				RequestBody:    extractRequestBodyInfo(op),
+				Excluded:       isOperationExcluded(op),
 			})
 		}
 	}
@@ -113,6 +114,21 @@ func deriveBaseURL(doc *highv3.Document, openAPIURL string) string {
 	return strings.TrimRight(parsedSpecURL.String(), "/")
 }
 
+func isOperationExcluded(op *highv3.Operation) bool {
+	if op == nil || op.Extensions == nil {
+		return false
+	}
+	for pair := orderedmap.First(op.Extensions); pair != nil; pair = pair.Next() {
+		if pair.Key() == "x-exclude-from-cli" {
+			node := pair.Value()
+			if node != nil && strings.ToLower(strings.TrimSpace(node.Value)) == "true" {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 func extractPathParamOrder(pathTemplate string) []string {
 	matches := pathParamPattern.FindAllStringSubmatch(pathTemplate, -1)
 	seen := make(map[string]struct{}, len(matches))