fix: skip optional prompts in flag mode for non-interactive scripting

ewega · ewega · commit 8d41177e59b0 · 2026-03-25T23:01:24.000+03:00
connection add: - Add isInteractive detection (connPlugin == '') - Skip optional org prompt in flag mode (fixes #147) - Error instead of prompt for required org in flag mode - Pass isInteractive to buildAndCreateConnection - Error instead of prompt for required username in flag mode project add: - Add --connections flag for flag-driven blueprint wiring Format: 'plugin:connID,...' e.g. 'github:1,gh-copilot:1' - Auto-discovers all scopes on specified connections - Skips interactive connection selection loop in flag mode - Interactive mode (no --connections) unchanged Tests: - TestIsInteractive_FlagMode: verifies flag mode detection - TestIsInteractive_OrgPromptDecision: 4 cases for org prompt logic - TestParseConnectionSpecs: 7 cases (valid, empty, invalid format, invalid ID, unknown plugin, alias resolution, whitespace) Closes #147
diff --git a/cmd/configure_connection_add.go b/cmd/configure_connection_add.go
@@ -78,6 +78,9 @@ func init() {
 func runAddConnection(cmd *cobra.Command, args []string) error {
 	printBanner("DevLake — Configure Connection")
 
+	// Flag mode = --plugin was provided → skip optional prompts.
+	isInteractive := connPlugin == ""
+
 	// ── Select plugin ──
 	def, err := selectPlugin(connPlugin)
 	if err != nil {
@@ -88,14 +91,17 @@ func runAddConnection(cmd *cobra.Command, args []string) error {
 	warnIrrelevantFlags(cmd, def, collectAllConnectionFlagDefs())
 	// In interactive mode (no --plugin), also show contextual help for
 	// the selected plugin's applicable flags.
-	if connPlugin == "" {
+	if isInteractive {
 		printContextualFlagHelp(def, def.ConnectionFlags, "Connection")
 		fmt.Println()
 	}
 
 	// ── Prompt for org if needed ──
 	org := connOrg
 	if def.NeedsOrg && org == "" {
+		if !isInteractive {
+			return fmt.Errorf("--org is required for %s", def.DisplayName)
+		}
 		orgPrompt := def.OrgPrompt
 		if orgPrompt == "" {
 			orgPrompt = "Organization slug"
@@ -108,7 +114,8 @@ func runAddConnection(cmd *cobra.Command, args []string) error {
 
 	// Prompt for org optionally for plugins that don't require it,
 	// so it gets saved to state for downstream commands (e.g. scopes).
-	if !def.NeedsOrg && org == "" {
+	// Only in interactive mode — flag mode skips optional prompts.
+	if !def.NeedsOrg && org == "" && isInteractive {
 		org = prompt.ReadLine("Organization slug (optional, press Enter to skip)")
 	}
 
@@ -148,11 +155,14 @@ func runAddConnection(cmd *cobra.Command, args []string) error {
 	if def.NeedsUsername {
 		username := resolveUsername(def, connUsername, connEnvFile)
 		if username == "" {
+			if !isInteractive {
+				return fmt.Errorf("--username is required for %s", def.DisplayName)
+			}
 			return fmt.Errorf("username is required for %s (provide it via --username or at the prompt)", def.DisplayName)
 		}
 		params.Username = username
 	}
-	result, err := buildAndCreateConnection(client, def, params, org, true)
+	result, err := buildAndCreateConnection(client, def, params, org, isInteractive)
 	if err != nil {
 		return err
 	}
diff --git a/cmd/configure_connection_add_test.go b/cmd/configure_connection_add_test.go
@@ -69,3 +69,86 @@ func TestSelectPlugin_AzureDevOpsAlias(t *testing.T) {
 		t.Errorf("expected plugin %q, got %q", "azuredevops_go", def.Plugin)
 	}
 }
+
+// TestIsInteractive_FlagMode verifies that setting --plugin triggers flag mode
+// (non-interactive), which is used by runAddConnection to skip optional prompts.
+func TestIsInteractive_FlagMode(t *testing.T) {
+	// When --plugin is provided → not interactive
+	pluginFlag := "github"
+	isInteractive := pluginFlag == ""
+	if isInteractive {
+		t.Error("expected isInteractive=false when connPlugin is set")
+	}
+
+	// When --plugin is empty → interactive
+	pluginFlag = ""
+	isInteractive = pluginFlag == ""
+	if !isInteractive {
+		t.Error("expected isInteractive=true when connPlugin is empty")
+	}
+}
+
+// TestIsInteractive_OrgPromptDecision verifies the org prompt logic:
+// - NeedsOrg=true + org="" + flag mode → should error (not prompt)
+// - NeedsOrg=false + org="" + flag mode → should skip (not prompt)
+// - NeedsOrg=false + org="" + interactive → would prompt (tested manually)
+func TestIsInteractive_OrgPromptDecision(t *testing.T) {
+	tests := []struct {
+		name          string
+		needsOrg      bool
+		org           string
+		isInteractive bool
+		wantPrompt    bool
+		wantError     bool
+	}{
+		{
+			name:          "NeedsOrg + no org + flag mode → error",
+			needsOrg:      true,
+			org:           "",
+			isInteractive: false,
+			wantPrompt:    false,
+			wantError:     true,
+		},
+		{
+			name:          "NeedsOrg + org provided + flag mode → no prompt",
+			needsOrg:      true,
+			org:           "my-org",
+			isInteractive: false,
+			wantPrompt:    false,
+			wantError:     false,
+		},
+		{
+			name:          "NoNeedsOrg + no org + flag mode → skip",
+			needsOrg:      false,
+			org:           "",
+			isInteractive: false,
+			wantPrompt:    false,
+			wantError:     false,
+		},
+		{
+			name:          "NoNeedsOrg + no org + interactive → would prompt",
+			needsOrg:      false,
+			org:           "",
+			isInteractive: true,
+			wantPrompt:    true,
+			wantError:     false,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			// Simulate the org prompt decision logic from runAddConnection
+			shouldPromptRequired := tc.needsOrg && tc.org == ""
+			shouldError := shouldPromptRequired && !tc.isInteractive
+			shouldPromptOptional := !tc.needsOrg && tc.org == "" && tc.isInteractive
+
+			if shouldError != tc.wantError {
+				t.Errorf("error: got %v, want %v", shouldError, tc.wantError)
+			}
+			gotPrompt := shouldPromptOptional || (shouldPromptRequired && tc.isInteractive)
+			if gotPrompt != tc.wantPrompt {
+				t.Errorf("prompt: got %v, want %v", gotPrompt, tc.wantPrompt)
+			}
+		})
+	}
+}
diff --git a/cmd/configure_project_add.go b/cmd/configure_project_add.go
@@ -1,9 +1,14 @@
 package cmd
 
 import (
+	"fmt"
+	"strconv"
+	"strings"
 	"time"
 
 	"github.com/spf13/cobra"
+
+	"github.com/DevExpGBB/gh-devlake/internal/devlake"
 )
 
 func newProjectAddCmd() *cobra.Command {
@@ -26,15 +31,23 @@ This command will:
   4. Configure a sync blueprint
   5. Trigger the first data collection
 
-Example:
+Flag mode (non-interactive):
+  Provide --project-name and --connections to skip all prompts.
+  --connections format: "plugin:connID,plugin:connID" e.g. "github:1,gh-copilot:1"
+  All scopes on each specified connection are included automatically.
+
+Example (interactive):
   gh devlake configure project add
-  gh devlake configure project add --project-name my-team`,
+
+Example (non-interactive):
+  gh devlake configure project add --project-name my-team --connections "github:1,gh-copilot:1"`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return runProjectAdd(cmd, args, &opts)
 		},
 	}
 
 	cmd.Flags().StringVar(&opts.ProjectName, "project-name", "", "DevLake project name")
+	cmd.Flags().StringVar(&opts.Connections, "connections", "", `Connections to include: "plugin:connID,..." (flag mode)`)
 	cmd.Flags().StringVar(&opts.TimeAfter, "time-after", "", "Only collect data after this date (default: 6 months ago)")
 	cmd.Flags().StringVar(&opts.Cron, "cron", "0 0 * * *", "Blueprint cron schedule")
 	cmd.Flags().BoolVar(&opts.SkipSync, "skip-sync", false, "Skip triggering the first data sync")
@@ -44,6 +57,112 @@ Example:
 	return cmd
 }
 
+// parseConnectionSpecs parses "github:1,gh-copilot:1" into connChoice entries.
+func parseConnectionSpecs(spec string) ([]connChoice, error) {
+	if spec == "" {
+		return nil, nil
+	}
+	parts := strings.Split(spec, ",")
+	var choices []connChoice
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		colonIdx := strings.LastIndex(p, ":")
+		if colonIdx < 0 {
+			return nil, fmt.Errorf("invalid connection spec %q — expected plugin:connID", p)
+		}
+		plugin := p[:colonIdx]
+		idStr := p[colonIdx+1:]
+		id, err := strconv.Atoi(idStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid connection ID %q in spec %q", idStr, p)
+		}
+		def := FindConnectionDef(plugin)
+		if def == nil {
+			return nil, fmt.Errorf("unknown plugin %q in connection spec", plugin)
+		}
+		choices = append(choices, connChoice{
+			plugin: def.Plugin,
+			id:     id,
+			label:  fmt.Sprintf("%s (ID: %d)", def.DisplayName, id),
+		})
+	}
+	return choices, nil
+}
+
 func runProjectAdd(cmd *cobra.Command, args []string, opts *ProjectOpts) error {
+	// Flag mode: --connections provided → non-interactive path
+	if opts.Connections != "" {
+		return runProjectAddFlagMode(cmd, args, opts)
+	}
 	return runConfigureProjects(cmd, args, opts)
 }
+
+// runProjectAddFlagMode creates a project non-interactively using --connections.
+func runProjectAddFlagMode(cmd *cobra.Command, args []string, opts *ProjectOpts) error {
+	printBanner("DevLake — Project Setup")
+
+	if opts.ProjectName == "" {
+		return fmt.Errorf("--project-name is required when using --connections")
+	}
+
+	specs, err := parseConnectionSpecs(opts.Connections)
+	if err != nil {
+		return fmt.Errorf("parsing --connections: %w", err)
+	}
+	if len(specs) == 0 {
+		return fmt.Errorf("--connections must specify at least one connection")
+	}
+
+	client := opts.Client
+	statePath := opts.StatePath
+	state := opts.State
+
+	// Discover DevLake if not pre-resolved by an orchestrator
+	if client == nil {
+		var disc *devlake.DiscoveryResult
+		client, disc, err = discoverClient(cfgURL)
+		if err != nil {
+			return err
+		}
+		statePath, state = devlake.FindStateFile(disc.URL, disc.GrafanaURL)
+	}
+
+	fmt.Printf("\n🔍 Discovering scopes for %d connection(s)...\n", len(specs))
+
+	var added []addedConnection
+	for _, spec := range specs {
+		ac, err := listConnectionScopes(client, spec)
+		if err != nil {
+			return fmt.Errorf("connection %s: %w", spec.label, err)
+		}
+		added = append(added, *ac)
+	}
+
+	// Accumulate results
+	var connections []devlake.BlueprintConnection
+	var allRepos []string
+	var pluginNames []string
+	for _, a := range added {
+		connections = append(connections, a.bpConn)
+		allRepos = append(allRepos, a.repos...)
+		pluginNames = append(pluginNames, pluginDisplayName(a.plugin))
+	}
+
+	return finalizeProject(finalizeProjectOpts{
+		Client:      client,
+		StatePath:   statePath,
+		State:       state,
+		ProjectName: opts.ProjectName,
+		Connections: connections,
+		Repos:       allRepos,
+		PluginNames: pluginNames,
+		Cron:        opts.Cron,
+		TimeAfter:   opts.TimeAfter,
+		SkipSync:    opts.SkipSync,
+		Wait:        opts.Wait,
+		Timeout:     opts.Timeout,
+	})
+}
diff --git a/cmd/configure_project_test.go b/cmd/configure_project_test.go
@@ -61,14 +61,98 @@ func TestNewProjectAddCmd_Flags(t *testing.T) {
 	if cmd.Use != "add" {
 		t.Errorf("expected Use %q, got %q", "add", cmd.Use)
 	}
-	flags := []string{"project-name", "time-after", "cron", "skip-sync", "wait", "timeout"}
+	flags := []string{"project-name", "connections", "time-after", "cron", "skip-sync", "wait", "timeout"}
 	for _, f := range flags {
 		if cmd.Flags().Lookup(f) == nil {
 			t.Errorf("expected flag --%s to be registered on project add cmd", f)
 		}
 	}
 }
 
+func TestParseConnectionSpecs_Valid(t *testing.T) {
+	specs, err := parseConnectionSpecs("github:1,gh-copilot:2")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(specs) != 2 {
+		t.Fatalf("expected 2 specs, got %d", len(specs))
+	}
+	if specs[0].plugin != "github" || specs[0].id != 1 {
+		t.Errorf("spec[0]: got plugin=%q id=%d, want github:1", specs[0].plugin, specs[0].id)
+	}
+	if specs[1].plugin != "gh-copilot" || specs[1].id != 2 {
+		t.Errorf("spec[1]: got plugin=%q id=%d, want gh-copilot:2", specs[1].plugin, specs[1].id)
+	}
+}
+
+func TestParseConnectionSpecs_Empty(t *testing.T) {
+	specs, err := parseConnectionSpecs("")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if specs != nil {
+		t.Errorf("expected nil for empty string, got %v", specs)
+	}
+}
+
+func TestParseConnectionSpecs_InvalidFormat(t *testing.T) {
+	_, err := parseConnectionSpecs("github-without-id")
+	if err == nil {
+		t.Fatal("expected error for missing colon separator")
+	}
+}
+
+func TestParseConnectionSpecs_InvalidID(t *testing.T) {
+	_, err := parseConnectionSpecs("github:abc")
+	if err == nil {
+		t.Fatal("expected error for non-numeric ID")
+	}
+}
+
+func TestParseConnectionSpecs_UnknownPlugin(t *testing.T) {
+	_, err := parseConnectionSpecs("nonexistent:1")
+	if err == nil {
+		t.Fatal("expected error for unknown plugin")
+	}
+}
+
+func TestParseConnectionSpecs_SingleConnection(t *testing.T) {
+	specs, err := parseConnectionSpecs("jenkins:5")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(specs) != 1 {
+		t.Fatalf("expected 1 spec, got %d", len(specs))
+	}
+	if specs[0].plugin != "jenkins" || specs[0].id != 5 {
+		t.Errorf("spec[0]: got plugin=%q id=%d, want jenkins:5", specs[0].plugin, specs[0].id)
+	}
+}
+
+func TestParseConnectionSpecs_PluginAlias(t *testing.T) {
+	specs, err := parseConnectionSpecs("azure-devops:3")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(specs) != 1 {
+		t.Fatalf("expected 1 spec, got %d", len(specs))
+	}
+	// Should resolve the alias to the real plugin slug
+	if specs[0].plugin != "azuredevops_go" {
+		t.Errorf("expected plugin %q after alias resolution, got %q", "azuredevops_go", specs[0].plugin)
+	}
+}
+
+func TestParseConnectionSpecs_WhitespaceHandling(t *testing.T) {
+	specs, err := parseConnectionSpecs(" github:1 , gh-copilot:2 ")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(specs) != 2 {
+		t.Fatalf("expected 2 specs, got %d", len(specs))
+	}
+}
+
 func TestNewProjectDeleteCmd_Flags(t *testing.T) {
 	cmd := newProjectDeleteCmd()
 	if cmd.Use != "delete" {
diff --git a/cmd/configure_projects.go b/cmd/configure_projects.go
