refactor: simplify codebase with shared helpers and reduced duplication

- Add logf() and tryResetInterpreter() helpers in RLM
- Extract prepareMessages() in Anthropic/Gemini providers
- Consolidate truncate functions to use core.Truncate()
- Simplify NewPooled() by removing ineffective pool logic
- Add iterationState and executeCodeBlocks() shared abstractions
- Organize magic numbers into named constants

Author: XiaoConstantine

cmd/benchmark/main.go

@@ -373,12 +373,9 @@ func loadTasks(path string) ([]Task, error) {
 	return tasks, nil
 }
 
-// truncate truncates a string to maxLen characters.
+// truncate truncates a string to maxLen characters (uses core.Truncate).
 func truncate(s string, maxLen int) string {
-	if len(s) <= maxLen {
-		return s
-	}
-	return s[:maxLen] + "..."
+	return core.Truncate(s, maxLen)
 }
 
 func main() {

pkg/core/types.go

@@ -126,10 +126,16 @@ func (e *DepthExceededError) Error() string {
 		e.CurrentDepth, e.MaxDepth, truncatePrompt(e.Prompt, 50))
 }
 
-// truncatePrompt truncates a prompt for error messages.
-func truncatePrompt(s string, maxLen int) string {
+// Truncate shortens a string to maxLen characters, adding "..." suffix if truncated.
+// This is a utility function used for logging and error messages.
+func Truncate(s string, maxLen int) string {
 	if len(s) <= maxLen {
 		return s
 	}
 	return s[:maxLen] + "..."
 }
+
+// truncatePrompt truncates a prompt for error messages (internal alias for Truncate).
+func truncatePrompt(s string, maxLen int) string {
+	return Truncate(s, maxLen)
+}

pkg/providers/anthropic.go

@@ -132,8 +132,8 @@ type streamEvent struct {
 	} `json:"usage,omitempty"`
 }
 
-// Complete implements rlm.LLMClient for root LLM orchestration.
-func (c *AnthropicClient) Complete(ctx context.Context, messages []core.Message) (core.LLMResponse, error) {
+// prepareMessages extracts system prompt and converts messages to API format.
+func (c *AnthropicClient) prepareMessages(messages []core.Message) (string, []anthropicMessage) {
 	var systemPrompt string
 	var apiMessages []anthropicMessage
 
@@ -147,6 +147,12 @@ func (c *AnthropicClient) Complete(ctx context.Context, messages []core.Message)
 			})
 		}
 	}
+	return systemPrompt, apiMessages
+}
+
+// Complete implements rlm.LLMClient for root LLM orchestration.
+func (c *AnthropicClient) Complete(ctx context.Context, messages []core.Message) (core.LLMResponse, error) {
+	systemPrompt, apiMessages := c.prepareMessages(messages)
 
 	reqBody := anthropicRequest{
 		Model:     c.model,
@@ -315,19 +321,7 @@ func (c *AnthropicClient) doRequest(ctx context.Context, reqBody anthropicReques
 // The handler is called for each chunk of content as it arrives.
 // Returns the complete response with token usage after stream completes.
 func (c *AnthropicClient) CompleteStream(ctx context.Context, messages []core.Message, handler StreamHandler) (core.LLMResponse, error) {
-	var systemPrompt string
-	var apiMessages []anthropicMessage
-
-	for _, msg := range messages {
-		if msg.Role == "system" {
-			systemPrompt = msg.Content
-		} else {
-			apiMessages = append(apiMessages, anthropicMessage{
-				Role:    msg.Role,
-				Content: msg.Content,
-			})
-		}
-	}
+	systemPrompt, apiMessages := c.prepareMessages(messages)
 
 	reqBody := anthropicRequest{
 		Model:     c.model,

pkg/providers/gemini.go

@@ -101,8 +101,8 @@ type geminiResponse struct {
 	} `json:"error,omitempty"`
 }
 
-// Complete implements rlm.LLMClient for root LLM orchestration.
-func (c *GeminiClient) Complete(ctx context.Context, messages []core.Message) (core.LLMResponse, error) {
+// prepareMessages extracts system instruction and converts messages to API format.
+func (c *GeminiClient) prepareMessages(messages []core.Message) (*geminiContent, []geminiContent) {
 	var systemContent *geminiContent
 	var contents []geminiContent
 
@@ -122,6 +122,12 @@ func (c *GeminiClient) Complete(ctx context.Context, messages []core.Message) (c
 			})
 		}
 	}
+	return systemContent, contents
+}
+
+// Complete implements rlm.LLMClient for root LLM orchestration.
+func (c *GeminiClient) Complete(ctx context.Context, messages []core.Message) (core.LLMResponse, error) {
+	systemContent, contents := c.prepareMessages(messages)
 
 	reqBody := geminiRequest{
 		Contents:          contents,
@@ -299,25 +305,7 @@ type geminiStreamChunk struct {
 // The handler is called for each chunk of content as it arrives.
 // Returns the complete response with token usage after stream completes.
 func (c *GeminiClient) CompleteStream(ctx context.Context, messages []core.Message, handler StreamHandler) (core.LLMResponse, error) {
-	var systemContent *geminiContent
-	var contents []geminiContent
-
-	for _, msg := range messages {
-		if msg.Role == "system" {
-			systemContent = &geminiContent{
-				Parts: []geminiPart{{Text: msg.Content}},
-			}
-		} else {
-			role := msg.Role
-			if role == "assistant" {
-				role = "model"
-			}
-			contents = append(contents, geminiContent{
-				Role:  role,
-				Parts: []geminiPart{{Text: msg.Content}},
-			})
-		}
-	}
+	systemContent, contents := c.prepareMessages(messages)
 
 	reqBody := geminiRequest{
 		Contents:          contents,

pkg/repl/repl.go

@@ -94,26 +94,9 @@ func (p *REPLPool) Stats() (poolSize, totalCreated int) {
 	return len(p.pool), p.created
 }
 
-// interpreterPool is a simple sync.Pool for basic interpreter reuse.
-// Note: Due to Yaegi limitations, interpreters can't be fully reset,
-// so this primarily helps with pre-warming the GC and memory allocation.
-var interpreterPool = sync.Pool{
-	New: func() interface{} {
-		stdout := new(bytes.Buffer)
-		stderr := new(bytes.Buffer)
-
-		i := interp.New(interp.Options{
-			Stdout: stdout,
-			Stderr: stderr,
-		})
-
-		if err := i.Use(stdlib.Symbols); err != nil {
-			panic(fmt.Sprintf("failed to load stdlib: %v", err))
-		}
-
-		return i
-	},
-}
+// Note: Yaegi interpreters cannot be reset to a clean state, so traditional
+// pooling (reusing the same interpreter across requests) is not possible.
+// See REPLPool for a pre-creation approach that helps with startup latency.
 
 // QueryResponse contains the LLM response with usage metadata.
 type QueryResponse struct {
@@ -205,49 +188,13 @@ func New(client LLMClient, opts ...REPLOption) *REPL {
 	return r
 }
 
-// NewPooled creates a new REPL instance using the interpreter pool.
-// This eliminates the 10-50ms startup overhead per REPL instance.
-// Call Close() when done to return the interpreter to the pool.
+// NewPooled creates a new REPL instance with pooling flags set.
+// Note: Due to Yaegi interpreter limitations (can't be reset to clean state),
+// this function simply creates a fresh REPL each time. The pooling flags are
+// preserved for compatibility, but actual interpreter reuse is not possible.
+// Consider using REPLPool for pre-created REPL instances if startup time matters.
 func NewPooled(client LLMClient) *REPL {
-	stdout := new(bytes.Buffer)
-	stderr := new(bytes.Buffer)
-
-	// Get interpreter from pool (will be created if pool is empty)
-	pooledInterp := interpreterPool.Get().(*interp.Interpreter)
-
-	// Create a new interpreter with fresh buffers
-	// Note: We can't reuse the pooled interpreter's buffers as they may contain stale data
-	// and we can't safely redirect them. Instead, we create a fresh interpreter.
-	i := interp.New(interp.Options{
-		Stdout: stdout,
-		Stderr: stderr,
-	})
-
-	// Load standard library
-	if err := i.Use(stdlib.Symbols); err != nil {
-		panic(fmt.Sprintf("failed to load stdlib: %v", err))
-	}
-
-	// Return the pooled interpreter since we can't fully reuse it
-	interpreterPool.Put(pooledInterp)
-
-	r := &REPL{
-		interp:       i,
-		stdout:       stdout,
-		stderr:       stderr,
-		llmClient:    client,
-		ctx:          context.Background(),
-		fromPool:     true,
-		usePooling:   true,
-		asyncQueries: make(map[string]*AsyncQueryHandle),
-	}
-
-	// Inject RLM functions
-	if err := r.injectBuiltins(); err != nil {
-		panic(fmt.Sprintf("failed to inject builtins: %v", err))
-	}
-
-	return r
+	return New(client, WithPooling(true))
 }
 
 // Close releases resources and returns the interpreter to the pool if applicable.