test message

Author: Patel230

cmd/iterate/repl.go

@@ -224,11 +224,13 @@ func handleModelProviderSwitch(line string, p *iteragent.Provider, thinking *ite
 			_ = (*a).Close() // best-effort cleanup
 			*a = makeAgent(*p, repoPath, *thinking, logger)
 			fmt.Printf("%s✓ switched to %s%s\n\n", colorLime, (*p).Name(), colorReset)
-			saveConfig(iterConfig{
-				Provider:      os.Getenv("ITERATE_PROVIDER"),
-				Model:         os.Getenv("ITERATE_MODEL"),
-				OllamaBaseURL: os.Getenv("OLLAMA_BASE_URL"),
-			})
+			// Preserve all existing config — only update provider/model fields.
+			updatedCfg := loadConfig()
+			updatedCfg.Provider = (*p).Name()
+			if model := os.Getenv("ITERATE_MODEL"); model != "" {
+				updatedCfg.Model = model
+			}
+			saveConfig(updatedCfg)
 		}
 		return true
 	}

internal/agent/pool.go

@@ -20,14 +20,14 @@ type Pool struct {
 	rateLimiter *RateLimiter
 	logger      *slog.Logger
 	maxAgents   int
-	wg          sync.WaitGroup
 }
 
 // RateLimiter controls API call frequency using token bucket algorithm.
 type RateLimiter struct {
 	tokens   chan struct{}
 	refill   time.Duration
 	stopChan chan struct{}
+	stopOnce sync.Once
 }
 
 // NewRateLimiter creates a rate limiter with the given requests per second.
@@ -70,9 +70,11 @@ func (rl *RateLimiter) Wait(ctx context.Context) error {
 	}
 }
 
-// Stop stops the rate limiter goroutine.
+// Stop stops the rate limiter goroutine. Safe to call multiple times.
 func (rl *RateLimiter) Stop() {
-	close(rl.stopChan)
+	rl.stopOnce.Do(func() {
+		close(rl.stopChan)
+	})
 }
 
 // NewPool creates an agent pool with rate limiting.
@@ -142,10 +144,6 @@ func (p *Pool) Spawn(ctx context.Context, task string, handler func(*iteragent.A
 		return err
 	}
 	defer p.Release(agent)
-
-	p.wg.Add(1)
-	defer p.wg.Done()
-
 	return handler(agent)
 }
 
@@ -154,10 +152,13 @@ func (p *Pool) Spawn(ctx context.Context, task string, handler func(*iteragent.A
 func (p *Pool) SpawnAll(ctx context.Context, tasks []string, handler func(*iteragent.Agent, string) error) []error {
 	errs := make([]error, len(tasks))
 	var errMu sync.Mutex
+	var wg sync.WaitGroup
 
 	for i, task := range tasks {
 		i, task := i, task // capture loop variables
+		wg.Add(1)          // must be before goroutine launch to avoid Wait() returning early
 		go func() {
+			defer wg.Done()
 			err := p.Spawn(ctx, task, func(agent *iteragent.Agent) error {
 				return handler(agent, task)
 			})
@@ -167,7 +168,7 @@ func (p *Pool) SpawnAll(ctx context.Context, tasks []string, handler func(*itera
 		}()
 	}
 
-	p.wg.Wait()
+	wg.Wait()
 	return errs
 }
 

internal/community/github.go

@@ -6,6 +6,7 @@ import (
 	"log/slog"
 	"os"
 	"sort"
+	"sync"
 
 	"github.com/google/go-github/v61/github"
 	"golang.org/x/oauth2"
@@ -73,37 +74,57 @@ func FetchIssues(ctx context.Context, owner, repo string, issueTypes []IssueType
 }
 
 // buildIssuesFromGitHub converts GitHub API issues to Issue structs with reaction scores.
+// Reaction fetches are fanned out concurrently to avoid N+1 serial API calls.
 func buildIssuesFromGitHub(ctx context.Context, client *github.Client, owner, repo string, ghIssues []*github.Issue, issueType IssueType) []Issue {
-	var issues []Issue
-	for _, gi := range ghIssues {
-		reactions, _, err := client.Reactions.ListIssueReactions(ctx, owner, repo, gi.GetNumber(), nil)
-		if err != nil {
-			continue
-		}
-
-		var up, down int
-		for _, r := range reactions {
-			switch r.GetContent() {
-			case "heart", "+1":
-				up++
-			case "-1":
-				down++
+	type slot struct {
+		issue Issue
+		ok    bool
+	}
+	slots := make([]slot, len(ghIssues))
+	var wg sync.WaitGroup
+
+	for i, gi := range ghIssues {
+		i, gi := i, gi
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			reactions, _, err := client.Reactions.ListIssueReactions(ctx, owner, repo, gi.GetNumber(), nil)
+			if err != nil {
+				return
 			}
-		}
+			var up, down int
+			for _, r := range reactions {
+				switch r.GetContent() {
+				case "heart", "+1":
+					up++
+				case "-1":
+					down++
+				}
+			}
+			body := gi.GetBody()
+			if len(body) > 500 {
+				body = body[:500] + "..."
+			}
+			slots[i] = slot{
+				issue: Issue{
+					Number:   gi.GetNumber(),
+					Title:    gi.GetTitle(),
+					Body:     body,
+					NetVotes: up - down,
+					URL:      gi.GetHTMLURL(),
+					Type:     issueType,
+				},
+				ok: true,
+			}
+		}()
+	}
+	wg.Wait()
 
-		body := gi.GetBody()
-		if len(body) > 500 {
-			body = body[:500] + "..."
+	var issues []Issue
+	for _, s := range slots {
+		if s.ok {
+			issues = append(issues, s.issue)
 		}
-
-		issues = append(issues, Issue{
-			Number:   gi.GetNumber(),
-			Title:    gi.GetTitle(),
-			Body:     body,
-			NetVotes: up - down,
-			URL:      gi.GetHTMLURL(),
-			Type:     issueType,
-		})
 	}
 	return issues
 }

internal/evolution/engine.go

@@ -34,23 +34,20 @@ var ProtectedFiles = []string{
 	"scripts/social/social.sh",
 }
 
-// isProtected checks if a file path matches any protected pattern.
+// isProtected checks if a relative file path matches any protected pattern.
+// path must already be relative to the repo root.
 func isProtected(path string) bool {
 	cleanPath := filepath.Clean(path)
 	for _, pattern := range ProtectedFiles {
 		// Check exact match
 		if cleanPath == filepath.Clean(pattern) {
 			return true
 		}
-		// Check glob pattern match
-		if matched, _ := filepath.Match(pattern, filepath.Base(cleanPath)); matched {
-			dir := filepath.Dir(cleanPath)
-			patternDir := filepath.Dir(pattern)
-			if dir == patternDir || patternDir == "." {
-				return true
-			}
+		// Check glob pattern match against the full relative path
+		if matched, _ := filepath.Match(pattern, cleanPath); matched {
+			return true
 		}
-		// Check if path is inside a protected directory
+		// Check if path is inside a protected directory (handles /*.go and /* suffixes)
 		if strings.HasSuffix(pattern, "/*") || strings.HasSuffix(pattern, "/*.go") {
 			protectedDir := strings.TrimSuffix(pattern, "/*")
 			protectedDir = strings.TrimSuffix(protectedDir, "/*.go")
@@ -73,6 +70,7 @@ type Engine struct {
 	prURL         string
 	branchName    string
 	traceID       string
+	toolMap       map[string]iteragent.Tool // cached at construction to avoid re-init per call
 }
 
 // generateTraceID creates a random hex trace ID for request correlation.
@@ -107,11 +105,13 @@ func New(repoPath string, logger *slog.Logger) *Engine {
 		repo = "GrayCodeAI/iterate"
 	}
 	tid := generateTraceID()
+	tools := iteragent.DefaultTools(repoPath)
 	e := &Engine{
 		repoPath: repoPath,
 		repo:     repo,
 		logger:   logger.With("traceID", tid),
 		traceID:  tid,
+		toolMap:  iteragent.ToolMap(tools),
 	}
 	// Load PR state from previous phase if exists
 	e.loadPRState()
@@ -177,10 +177,9 @@ func (e *Engine) WithThinking(level iteragent.ThinkingLevel) *Engine {
 // Run executes one full evolution session.
 func (e *Engine) handlePostRunTests(ctx context.Context, day int, output string, p iteragent.Provider, tools []iteragent.Tool, skills *iteragent.SkillSet, result *RunResult) error {
 	testResult, testErr := e.runTests(ctx)
-	_ = testResult
 
 	if testErr != nil {
-		e.logger.Info("tests failed, reverting changes")
+		e.logger.Info("tests failed, reverting changes", "output", testResult)
 		result.Status = "reverted"
 		_ = e.revert(ctx)
 		return nil
@@ -259,7 +258,7 @@ func (e *Engine) readContextFiles() ([]byte, []byte, int) {
 func (e *Engine) runAgentAndCollectEvents(ctx context.Context, a *iteragent.Agent, userMessage string) (string, error) {
 	eventCh := a.Prompt(ctx, userMessage)
 	var output string
-	var runErr error
+	var errs []string
 	for ev := range eventCh {
 		if e.eventSink != nil {
 			select {
@@ -271,10 +270,13 @@ func (e *Engine) runAgentAndCollectEvents(ctx context.Context, a *iteragent.Agen
 			output = ev.Content
 		}
 		if ev.Type == string(iteragent.EventError) {
-			runErr = fmt.Errorf("%s", ev.Content)
+			errs = append(errs, ev.Content)
 		}
 	}
-	return output, runErr
+	if len(errs) > 0 {
+		return output, fmt.Errorf("%s", strings.Join(errs, "; "))
+	}
+	return output, nil
 }
 
 // handleCommitAndPR creates a branch, commits, pushes, and creates a PR.

internal/evolution/git.go

@@ -13,9 +13,7 @@ import (
 )
 
 func (e *Engine) runTool(ctx context.Context, name string, args map[string]string) (string, error) {
-	tools := iteragent.DefaultTools(e.repoPath)
-	tm := iteragent.ToolMap(tools)
-	tool, ok := tm[name]
+	tool, ok := e.toolMap[name]
 	if !ok {
 		return "", fmt.Errorf("tool %q not found", name)
 	}
@@ -127,10 +125,10 @@ func (e *Engine) createPR(ctx context.Context, title, body string, issueNums []i
 
 	url := strings.TrimSpace(out)
 	var prNum int
-	fmt.Sscanf(url, "%*s/%d", &prNum)
 	if idx := strings.LastIndex(url, "/"); idx >= 0 {
-		numStr := url[idx+1:]
-		fmt.Sscanf(numStr, "%d", &prNum)
+		if _, err := fmt.Sscanf(url[idx+1:], "%d", &prNum); err != nil {
+			e.logger.Warn("could not parse PR number from URL", "url", url)
+		}
 	}
 
 	e.prURL = url
@@ -208,7 +206,7 @@ func (e *Engine) mergePR(ctx context.Context) error {
 	})
 	if err != nil {
 		if strings.Contains(strings.ToLower(out), "no mergeable") || strings.Contains(strings.ToLower(out), "conflict") {
-			e.logger.Warn("PR has merge conflicts, attempting auto-merge")
+			e.logger.Warn("PR has merge conflicts, attempting merge with --admin flag (bypasses branch protection)", "pr", e.prNumber)
 			mergeOut, mergeErr := e.runTool(ctx, "bash", map[string]string{
 				"cmd": fmt.Sprintf("gh pr merge %d --repo %s --squash --admin --delete-branch 2>&1 || echo 'MERGE_FAILED'", e.prNumber, e.repo),
 			})
@@ -254,9 +252,7 @@ func (e *Engine) forwardEvents(src <-chan iteragent.Event) {
 }
 
 func (e *Engine) runTests(ctx context.Context) (string, error) {
-	tools := iteragent.DefaultTools(e.repoPath)
-	tm := iteragent.ToolMap(tools)
-	return tm["run_tests"].Execute(ctx, nil)
+	return e.toolMap["run_tests"].Execute(ctx, nil)
 }
 
 // defaultPhaseTimeout is the maximum duration for any evolution phase.
@@ -268,25 +264,19 @@ func withTimeout(ctx context.Context) (context.Context, context.CancelFunc) {
 }
 
 func (e *Engine) revert(ctx context.Context) error {
-	tools := iteragent.DefaultTools(e.repoPath)
-	tm := iteragent.ToolMap(tools)
-
-	// First, reset all staged and unstaged changes
-	_, err := e.runTool(ctx, "bash", map[string]string{
+	// Reset uncommitted changes first.
+	if _, err := e.runTool(ctx, "bash", map[string]string{
 		"cmd": "git checkout -- . && git clean -fd",
-	})
-	if err != nil {
-		e.logger.Warn("git checkout failed, trying revert tool", "err", err)
+	}); err == nil {
+		return nil
 	}
-
-	// Then use the revert tool for any committed changes
-	_, err = tm["git_revert"].Execute(ctx, nil)
+	// Fall back: use git_revert tool for any committed changes.
+	e.logger.Warn("git checkout failed, trying revert tool")
+	_, err := e.toolMap["git_revert"].Execute(ctx, nil)
 	return err
 }
 
 func (e *Engine) commit(ctx context.Context, msg string) error {
-	tools := iteragent.DefaultTools(e.repoPath)
-	tm := iteragent.ToolMap(tools)
-	_, err := tm["git_commit"].Execute(ctx, map[string]string{"message": msg})
+	_, err := e.toolMap["git_commit"].Execute(ctx, map[string]string{"message": msg})
 	return err
 }