test message

Author: Patel230

cmd/iterate/features_tools.go

@@ -21,9 +21,38 @@ import (
 // ---------------------------------------------------------------------------
 
 // spinnerActive is set to 1 while the spinner goroutine is printing.
-// Tool wrappers wait for it to reach 0 before showing a prompt.
 var spinnerActive atomic.Int32
 
+// spinnerQuiet is closed by the spinner goroutine when it finishes clearing
+// the terminal line. Safe-mode prompts wait on this instead of busy-looping.
+var spinnerQuiet = make(chan struct{})
+
+func init() {
+	// Start closed so the first prompt doesn't block if no spinner ever ran.
+	close(spinnerQuiet)
+}
+
+// notifySpinnerQuiet replaces spinnerQuiet with a new open channel, then
+// closes the old one so any waiters unblock. Called by the spinner when done.
+func notifySpinnerQuiet() {
+	old := spinnerQuiet
+	spinnerQuiet = make(chan struct{})
+	select {
+	case <-old:
+	default:
+		close(old)
+	}
+}
+
+// waitForSpinner blocks until the spinner has stopped and cleared the line,
+// or until 500 ms have elapsed (so a stuck spinner never deadlocks a prompt).
+func waitForSpinner() {
+	select {
+	case <-spinnerQuiet:
+	case <-time.After(500 * time.Millisecond):
+	}
+}
+
 // streamingTokenCount is incremented for each token received during streaming.
 // The spinner reads this to display tok/s.
 var streamingTokenCount atomic.Int64
@@ -245,9 +274,7 @@ func handleSafeModePrompt(cfg iterConfig, tool iteragent.Tool, args map[string]s
 		}
 	}
 
-	for spinnerActive.Load() == 1 {
-		time.Sleep(5 * time.Millisecond)
-	}
+	waitForSpinner()
 	fmt.Printf("\n%s⚠ Safe mode: allow %s?%s ", colorYellow, tool.Name, colorReset)
 	answer, ok := selector.PromptLine("(y/N/always):")
 	if !ok {

cmd/iterate/main_flags.go

@@ -33,9 +33,10 @@ func parseFlags() mainFlags {
 	flag.IntVar(&f.issueMax, "issue-limit", 5, "Max community issues to include")
 	flag.BoolVar(&f.socialOnly, "social", false, "Run social loop only (no evolution)")
 	flag.BoolVar(&f.replyIssues, "reply-issues", true, "Post bot replies to addressed issues")
-	flag.StringVar(&f.provider, "provider", "gemini", "Provider to use (anthropic, openai, groq, gemini)")
-	flag.StringVar(&f.model, "model", "", "Model to use")
-	flag.StringVar(&f.apiKey, "api-key", "", "API key (or set OPENCODE_API_KEY, GEMINI_API_KEY, etc.)")
+	flag.StringVar(&f.provider, "provider", "gemini",
+		"LLM provider: anthropic, openai, gemini, groq, ollama, azure, vertex, opencode (default: gemini)")
+	flag.StringVar(&f.model, "model", "", "Model name override (e.g. claude-opus-4-6, gpt-4o, gemini-2.0-flash)")
+	flag.StringVar(&f.apiKey, "api-key", "", "API key override (or set ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, GROQ_API_KEY, etc.)")
 	flag.StringVar(&f.thinking, "thinking", "off", "Extended thinking depth: off, minimal, low, medium, high")
 	flag.BoolVar(&f.chat, "chat", false, "Start interactive REPL (default when no other mode set)")
 	flag.BoolVar(&f.evolve, "evolve", false, "Run one evolution session (non-interactive)")

cmd/iterate/provider.go

@@ -1,8 +1,12 @@
 package main
 
 import (
+	"context"
+	"fmt"
 	"log/slog"
 	"os"
+	"strings"
+	"time"
 
 	iteragent "github.com/GrayCodeAI/iteragent"
 	"github.com/GrayCodeAI/iterate/internal/ui/selector"
@@ -44,13 +48,50 @@ func resolveThinkingLevel(flagThinking string, cfg iterConfig) string {
 }
 
 // initProvider creates an LLM provider from the given name and API key.
-// It also wires the provider's context window into the selector for display.
+// It also wires the provider's context window into the selector for display,
+// and runs a background health check to surface auth errors early.
 func initProvider(providerName, apiKey string, logger *slog.Logger) (iteragent.Provider, error) {
 	p, err := iteragent.NewProvider(providerName, apiKey)
 	if err != nil {
 		return nil, err
 	}
 	logger.Info("using provider", "name", p.Name())
 	selector.ContextWindow = iteragent.ProviderContextWindow(p)
+
+	// Skip health check for Ollama (local — no auth needed) and when
+	// the user explicitly passed --no-health-check (not currently a flag,
+	// but the env var ITERATE_SKIP_HEALTH_CHECK=1 disables it).
+	if os.Getenv("ITERATE_SKIP_HEALTH_CHECK") != "1" &&
+		!strings.EqualFold(providerName, "ollama") {
+		go runProviderHealthCheck(p, logger)
+	}
+
 	return p, nil
 }
+
+// runProviderHealthCheck sends a minimal prompt and prints a warning if the
+// provider returns an auth / connectivity error. Runs in a goroutine so it
+// doesn't block startup.
+func runProviderHealthCheck(p iteragent.Provider, logger *slog.Logger) {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	ag := iteragent.New(p, nil, logger)
+	events := ag.Prompt(ctx, "ping")
+	for e := range events {
+		if iteragent.EventType(e.Type) == iteragent.EventError {
+			hint := authErrorHint(e.Content)
+			fmt.Printf("\n%s⚠  Provider health check failed: %s%s\n", colorYellow, e.Content, colorReset)
+			if hint != "" {
+				fmt.Printf("%s   Fix: %s%s\n", colorYellow, hint, colorReset)
+			}
+			logger.Warn("provider health check failed", "error", e.Content)
+			return
+		}
+		// Got any non-error event — provider is reachable.
+		if iteragent.EventType(e.Type) == iteragent.EventTokenUpdate {
+			ag.Finish()
+			return
+		}
+	}
+}

cmd/iterate/repl_streaming.go

@@ -60,6 +60,7 @@ func spinner(stop <-chan struct{}, done chan<- struct{}, label string) {
 		case <-stop:
 			spinnerActive.Store(0)
 			fmt.Print("\r\033[K")
+			notifySpinnerQuiet()
 			close(done)
 			return
 		default:
@@ -247,7 +248,12 @@ func processStreamEvent(e iteragent.Event, fullContent string, toolStart time.Ti
 	case iteragent.EventContextCompacted:
 		fmt.Printf("\r\033[K%s[context compacted]%s\n", colorDim, colorReset)
 	case iteragent.EventError:
-		fmt.Printf("\r\033[K%sError: %s%s\n", colorRed, e.Content, colorReset)
+		msg := e.Content
+		hint := authErrorHint(msg)
+		fmt.Printf("\r\033[K%sError: %s%s\n", colorRed, msg, colorReset)
+		if hint != "" {
+			fmt.Printf("%sFix: %s%s\n", colorYellow, hint, colorReset)
+		}
 	}
 	return fullContent, toolStart
 }
@@ -298,3 +304,41 @@ func printFinalStats(elapsed, ttft time.Duration, beforeTokens int, requestCostU
 
 	slog.Debug("request completed", "elapsed_ms", elapsed.Milliseconds(), "ttft_ms", ttft.Milliseconds(), "response_chars", len(fullContent), "total_tokens", sess.Tokens, "cost_usd", requestCostUSD)
 }
+
+// authErrorHint returns a human-readable fix suggestion for known API error
+// patterns, or an empty string when the error doesn't look auth-related.
+func authErrorHint(errMsg string) string {
+	lower := strings.ToLower(errMsg)
+	switch {
+	case strings.Contains(lower, "401") || strings.Contains(lower, "unauthorized") ||
+		strings.Contains(lower, "invalid_api_key") || strings.Contains(lower, "authentication_error") ||
+		strings.Contains(lower, "invalid api key"):
+		provider := os.Getenv("ITERATE_PROVIDER")
+		switch strings.ToLower(provider) {
+		case "anthropic", "":
+			return "Set ANTHROPIC_API_KEY in your shell: export ANTHROPIC_API_KEY=sk-ant-..."
+		case "openai":
+			return "Set OPENAI_API_KEY in your shell: export OPENAI_API_KEY=sk-..."
+		case "gemini":
+			return "Set GEMINI_API_KEY in your shell: export GEMINI_API_KEY=AIza..."
+		case "groq":
+			return "Set GROQ_API_KEY in your shell: export GROQ_API_KEY=gsk_..."
+		case "ollama":
+			return "Ollama should not require an API key — check that Ollama is running (ollama serve)"
+		case "azure":
+			return "Set AZURE_OPENAI_API_KEY and AZURE_OPENAI_ENDPOINT in your shell"
+		default:
+			return "Check that your API key environment variable is set correctly (see /providers)"
+		}
+	case strings.Contains(lower, "403") || strings.Contains(lower, "forbidden") ||
+		strings.Contains(lower, "permission_denied"):
+		return "Your API key may lack permissions for this model — check your billing/plan"
+	case strings.Contains(lower, "429") || strings.Contains(lower, "rate_limit") ||
+		strings.Contains(lower, "too many requests"):
+		return "Rate limit hit — wait a moment and try again, or use /model to switch to a different model"
+	case strings.Contains(lower, "no api key") || strings.Contains(lower, "api key not set") ||
+		strings.Contains(lower, "missing api key"):
+		return "Run /providers to see which environment variable needs to be set"
+	}
+	return ""
+}

internal/commands/config.go

@@ -235,16 +235,52 @@ func cmdNotify(ctx Context) Result {
 
 func cmdEnv(ctx Context) Result {
 	if !ctx.HasArg(1) {
-		filter := []string{"ITERATE", "OLLAMA", "ANTHROPIC", "OPENAI", "GEMINI", "GROQ", "GITHUB", "GO"}
+		// Prefixes: any env var whose name starts with one of these is shown.
+		prefixes := []string{
+			"ITERATE_", "OLLAMA_", "ANTHROPIC_", "OPENAI_", "GEMINI_",
+			"GROQ_", "GITHUB_", "AZURE_", "VERTEX_", "OPENCODE_",
+		}
+		// Exact names also shown (without the _ prefix requirement).
+		exact := []string{"GOPATH", "GOROOT", "HOME", "SHELL"}
+
 		fmt.Printf("%s── Environment ─────────────────────%s\n", ColorDim, ColorReset)
-		for _, f := range filter {
-			val := os.Getenv(f)
-			if val != "" {
-				if len(val) > 60 {
-					val = val[:60] + "…"
+		for _, e := range os.Environ() {
+			kv := strings.SplitN(e, "=", 2)
+			if len(kv) != 2 {
+				continue
+			}
+			k, v := kv[0], kv[1]
+			matched := false
+			for _, p := range prefixes {
+				if strings.HasPrefix(k, p) {
+					matched = true
+					break
+				}
+			}
+			if !matched {
+				for _, ex := range exact {
+					if k == ex {
+						matched = true
+						break
+					}
+				}
+			}
+			if !matched {
+				continue
+			}
+			display := v
+			// Mask keys — show first 8 chars + …
+			lk := strings.ToLower(k)
+			if strings.Contains(lk, "key") || strings.Contains(lk, "token") || strings.Contains(lk, "secret") {
+				if len(v) > 8 {
+					display = v[:8] + "…"
+				} else if len(v) > 0 {
+					display = "***"
 				}
-				fmt.Printf("  %s=%s\n", f, val)
+			} else if len(display) > 80 {
+				display = display[:80] + "…"
 			}
+			fmt.Printf("  %s%s%s=%s\n", ColorBold, k, ColorReset, display)
 		}
 		fmt.Printf("%s──────────────────────────────────%s\n\n", ColorDim, ColorReset)
 		return Result{Handled: true}