recursive-llm-ts 2.0.12 → 3.0.1

package/go/internal/rlm/repl.go

@@ -0,0 +1,260 @@
+package rlm
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/dop251/goja"
+)
+
+type REPLExecutor struct {
+	maxOutputChars int
+}
+
+func NewREPLExecutor() *REPLExecutor {
+	return &REPLExecutor{
+		maxOutputChars: 2000,
+	}
+}
+
+func (r *REPLExecutor) Execute(code string, env map[string]interface{}) (string, error) {
+	code = extractCode(code)
+	if strings.TrimSpace(code) == "" {
+		return "No code to execute", nil
+	}
+
+	vm := goja.New()
+	var output strings.Builder
+
+	for key, value := range env {
+		vm.Set(key, value)
+	}
+
+	writeOutput := func(call goja.FunctionCall) goja.Value {
+		parts := make([]string, 0, len(call.Arguments))
+		for _, arg := range call.Arguments {
+			parts = append(parts, arg.String())
+		}
+		output.WriteString(strings.Join(parts, " "))
+		output.WriteString("\n")
+		return goja.Undefined()
+	}
+
+	console := map[string]func(goja.FunctionCall) goja.Value{
+		"log": writeOutput,
+	}
+
+	vm.Set("console", console)
+	vm.Set("print", writeOutput)
+	vm.Set("len", func(value goja.Value) int {
+		if value == nil || value == goja.Undefined() || value == goja.Null() {
+			return 0
+		}
+		if exported := value.Export(); exported != nil {
+			switch typed := exported.(type) {
+			case string:
+				return len(typed)
+			case []interface{}:
+				return len(typed)
+			case map[string]interface{}:
+				return len(typed)
+			}
+		}
+		return len(value.String())
+	})
+
+	if _, err := vm.RunString(jsBootstrap); err != nil {
+		return "", NewREPLError("Bootstrap execution error", jsBootstrap, err)
+	}
+
+	if _, err := vm.RunString(code); err != nil {
+		return "", NewREPLError("Code execution error", code, err)
+	}
+
+	if output.Len() == 0 {
+		lastLine := getLastLine(code)
+		if looksLikeExpression(lastLine) {
+			value, err := vm.RunString(lastLine)
+			if err == nil && value != nil && value != goja.Undefined() {
+				output.WriteString(value.String())
+				output.WriteString("\n")
+			}
+		}
+	}
+
+	if output.Len() == 0 {
+		return "Code executed successfully (no output)", nil
+	}
+
+	rawOutput := output.String()
+	trimmedOutput := strings.TrimSpace(rawOutput)
+	if len(rawOutput) > r.maxOutputChars {
+		truncated := rawOutput[:r.maxOutputChars]
+		return fmt.Sprintf("%s\n\n[Output truncated: %d chars total, showing first %d]", strings.TrimSpace(truncated), len(rawOutput), r.maxOutputChars), nil
+	}
+
+	return trimmedOutput, nil
+}
+
+func extractCode(text string) string {
+	if strings.Contains(text, "```python") {
+		return extractBlock(text, "```python")
+	}
+	if strings.Contains(text, "```javascript") {
+		return extractBlock(text, "```javascript")
+	}
+	if strings.Contains(text, "```js") {
+		return extractBlock(text, "```js")
+	}
+	if strings.Contains(text, "```") {
+		return extractBlock(text, "```")
+	}
+	return text
+}
+
+const jsBootstrap = `
+const json = {
+  loads: (text) => JSON.parse(text),
+  dumps: (value, replacer, space) => JSON.stringify(value, replacer, space),
+};
+const math = Math;
+const datetime = Date;
+const Counter = (iterable) => {
+  const counts = {};
+  if (iterable == null) {
+    return counts;
+  }
+  const items = typeof iterable === "string" ? iterable.split("") : iterable;
+  for (const item of items) {
+    const key = String(item);
+    counts[key] = (counts[key] || 0) + 1;
+  }
+  return counts;
+};
+const defaultdict = (defaultFactory) => new Proxy({}, {
+  get(target, prop) {
+    if (!(prop in target)) {
+      target[prop] = typeof defaultFactory === "function" ? defaultFactory() : defaultFactory;
+    }
+    return target[prop];
+  },
+});
+const range = (start, stop, step) => {
+  if (stop === undefined) {
+    stop = start;
+    start = 0;
+  }
+  if (step === undefined) {
+    step = 1;
+  }
+  if (step === 0) {
+    return [];
+  }
+  const result = [];
+  if (step > 0) {
+    for (let i = start; i < stop; i += step) {
+      result.push(i);
+    }
+  } else {
+    for (let i = start; i > stop; i += step) {
+      result.push(i);
+    }
+  }
+  return result;
+};
+const sorted = (iterable, compareFn) => [...iterable].sort(compareFn);
+const sum = (iterable) => (iterable || []).reduce((acc, value) => acc + Number(value), 0);
+const min = (iterable) => Math.min(...iterable);
+const max = (iterable) => Math.max(...iterable);
+const enumerate = (iterable) => (iterable || []).map((value, index) => [index, value]);
+const zip = (...iterables) => {
+  const length = Math.min(...iterables.map((items) => items.length));
+  const result = [];
+  for (let i = 0; i < length; i++) {
+    result.push(iterables.map((items) => items[i]));
+  }
+  return result;
+};
+const any = (iterable) => (iterable || []).some(Boolean);
+const all = (iterable) => (iterable || []).every(Boolean);
+`
+
+func extractBlock(text string, marker string) string {
+	start := strings.Index(text, marker)
+	if start == -1 {
+		return text
+	}
+	start += len(marker)
+	end := strings.Index(text[start:], "```")
+	if end == -1 {
+		return text[start:]
+	}
+	return strings.TrimSpace(text[start : start+end])
+}
+
+func getLastLine(code string) string {
+	lines := strings.Split(strings.TrimSpace(code), "\n")
+	if len(lines) == 0 {
+		return ""
+	}
+	lastLine := strings.TrimSpace(lines[len(lines)-1])
+	// Handle multiple statements on same line separated by semicolon
+	if strings.Contains(lastLine, ";") {
+		parts := strings.Split(lastLine, ";")
+		// Get the last non-empty part
+		for i := len(parts) - 1; i >= 0; i-- {
+			if trimmed := strings.TrimSpace(parts[i]); trimmed != "" {
+				return trimmed
+			}
+		}
+	}
+	return lastLine
+}
+
+func looksLikeExpression(line string) bool {
+	if line == "" {
+		return false
+	}
+	// Check for statements that shouldn't be evaluated as expressions
+	keywords := []string{"const ", "let ", "var ", "function ", "if ", "for ", "while ", "class ", "return "}
+	for _, keyword := range keywords {
+		if strings.HasPrefix(strings.TrimSpace(line), keyword) {
+			return false
+		}
+	}
+	// Check for assignment (but not == or === comparison)
+	if strings.Contains(line, "=") && !strings.Contains(line, "==") && !strings.Contains(line, "===") {
+		return false
+	}
+	return true
+}
+
+func NewRegexHelper() map[string]func(string, string) interface{} {
+	return map[string]func(string, string) interface{}{
+		"findall": func(pattern string, text string) interface{} {
+			re, err := regexpFromPattern(pattern)
+			if err != nil {
+				return []string{}
+			}
+			return re.FindAllString(text, -1)
+		},
+		"search": func(pattern string, text string) interface{} {
+			re, err := regexpFromPattern(pattern)
+			if err != nil {
+				return ""
+			}
+			match := re.FindString(text)
+			return match
+		},
+	}
+}
+
+func regexpFromPattern(pattern string) (*regexp.Regexp, error) {
+	re, err := regexp.Compile(pattern)
+	if err != nil {
+		return nil, errors.New("invalid regex pattern")
+	}
+	return re, nil
+}

package/go/internal/rlm/repl_test.go

@@ -0,0 +1,291 @@
+package rlm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestREPLExecutor_BasicExecution(t *testing.T) {
+	repl := NewREPLExecutor()
+
+	tests := []struct {
+		name    string
+		code    string
+		env     map[string]interface{}
+		want    string
+		wantErr bool
+	}{
+		{
+			name: "Simple print",
+			code: `console.log("Hello World")`,
+			env:  map[string]interface{}{},
+			want: "Hello World",
+		},
+		{
+			name: "Variable access",
+			code: `console.log(context)`,
+			env:  map[string]interface{}{"context": "Test Context"},
+			want: "Test Context",
+		},
+		{
+			name: "String slicing",
+			code: `console.log(context.slice(0, 5))`,
+			env:  map[string]interface{}{"context": "Hello World"},
+			want: "Hello",
+		},
+		{
+			name: "len function",
+			code: `console.log(len(context))`,
+			env:  map[string]interface{}{"context": "Hello"},
+			want: "5",
+		},
+		{
+			name: "regex findall",
+			code: `console.log(re.findall("ERROR", context))`,
+			env:  map[string]interface{}{"context": "ERROR 1 ERROR 2", "re": NewRegexHelper()},
+			want: "ERROR,ERROR",
+		},
+		{
+			name: "Last expression evaluation",
+			code: `const x = 42; x`,
+			env:  map[string]interface{}{},
+			want: "42",
+		},
+		{
+			name: "Array operations",
+			code: `const arr = [1, 2, 3]; console.log(arr.length)`,
+			env:  map[string]interface{}{},
+			want: "3",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := repl.Execute(tt.code, tt.env)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Execute() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !tt.wantErr && got != tt.want {
+				t.Errorf("Execute() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestREPLExecutor_CodeExtraction(t *testing.T) {
+	repl := NewREPLExecutor()
+
+	tests := []struct {
+		name string
+		code string
+		env  map[string]interface{}
+		want string
+	}{
+		{
+			name: "JavaScript code block",
+			code: "```javascript\nconsole.log('test')\n```",
+			env:  map[string]interface{}{},
+			want: "test",
+		},
+		{
+			name: "Python code block (should still extract)",
+			code: "```python\nconsole.log('test')\n```",
+			env:  map[string]interface{}{},
+			want: "test",
+		},
+		{
+			name: "Generic code block",
+			code: "```\nconsole.log('test')\n```",
+			env:  map[string]interface{}{},
+			want: "test",
+		},
+		{
+			name: "No code block",
+			code: "console.log('test')",
+			env:  map[string]interface{}{},
+			want: "test",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := repl.Execute(tt.code, tt.env)
+			if err != nil {
+				t.Errorf("Execute() error = %v", err)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("Execute() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestREPLExecutor_JSBootstrap(t *testing.T) {
+	repl := NewREPLExecutor()
+
+	tests := []struct {
+		name string
+		code string
+		want string
+	}{
+		{
+			name: "json.loads",
+			code: `const obj = json.loads('{"key":"value"}'); console.log(obj.key)`,
+			want: "value",
+		},
+		{
+			name: "json.dumps",
+			code: `console.log(json.dumps({key: "value"}))`,
+			want: `{"key":"value"}`,
+		},
+		{
+			name: "range",
+			code: `console.log(range(5).length)`,
+			want: "5",
+		},
+		{
+			name: "sum",
+			code: `console.log(sum([1, 2, 3]))`,
+			want: "6",
+		},
+		{
+			name: "Counter",
+			code: `const c = Counter("hello"); console.log(c.l)`,
+			want: "2",
+		},
+		{
+			name: "sorted",
+			code: `console.log(sorted([3, 1, 2]).join(','))`,
+			want: "1,2,3",
+		},
+		{
+			name: "enumerate",
+			code: `console.log(enumerate(['a', 'b']).length)`,
+			want: "2",
+		},
+		{
+			name: "zip",
+			code: `console.log(zip([1, 2], ['a', 'b']).length)`,
+			want: "2",
+		},
+		{
+			name: "any",
+			code: `console.log(any([false, true, false]))`,
+			want: "true",
+		},
+		{
+			name: "all",
+			code: `console.log(all([true, true, true]))`,
+			want: "true",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := repl.Execute(tt.code, map[string]interface{}{})
+			if err != nil {
+				t.Errorf("Execute() error = %v", err)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("Execute() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestREPLExecutor_OutputTruncation(t *testing.T) {
+	repl := NewREPLExecutor()
+	repl.maxOutputChars = 50
+
+	longOutput := strings.Repeat("x", 100)
+	code := `console.log("` + longOutput + `")`
+
+	got, err := repl.Execute(code, map[string]interface{}{})
+	if err != nil {
+		t.Errorf("Execute() error = %v", err)
+		return
+	}
+
+	if len(got) <= repl.maxOutputChars {
+		t.Errorf("Expected truncation, but got length %d", len(got))
+	}
+
+	if !strings.Contains(got, "[Output truncated") {
+		t.Errorf("Expected truncation message in output")
+	}
+}
+
+func TestREPLExecutor_ErrorHandling(t *testing.T) {
+	repl := NewREPLExecutor()
+
+	tests := []struct {
+		name    string
+		code    string
+		wantErr bool
+	}{
+		{
+			name:    "Syntax error",
+			code:    `const x = ;`,
+			wantErr: true,
+		},
+		{
+			name:    "Reference error",
+			code:    `console.log(undefinedVariable)`,
+			wantErr: true,
+		},
+		{
+			name:    "Valid code",
+			code:    `console.log("ok")`,
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := repl.Execute(tt.code, map[string]interface{}{})
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Execute() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestRegexHelper(t *testing.T) {
+	re := NewRegexHelper()
+
+	t.Run("findall", func(t *testing.T) {
+		result := re["findall"]("ERROR", "ERROR 1 ERROR 2 WARNING")
+		matches, ok := result.([]string)
+		if !ok {
+			t.Fatal("Expected []string from findall")
+		}
+		if len(matches) != 2 {
+			t.Errorf("Expected 2 matches, got %d", len(matches))
+		}
+	})
+
+	t.Run("search", func(t *testing.T) {
+		result := re["search"]("ERROR", "INFO ERROR WARNING")
+		match, ok := result.(string)
+		if !ok {
+			t.Fatal("Expected string from search")
+		}
+		if match != "ERROR" {
+			t.Errorf("Expected 'ERROR', got %q", match)
+		}
+	})
+
+	t.Run("no match", func(t *testing.T) {
+		result := re["search"]("ERROR", "INFO WARNING")
+		match, ok := result.(string)
+		if !ok {
+			t.Fatal("Expected string from search")
+		}
+		if match != "" {
+			t.Errorf("Expected empty string, got %q", match)
+		}
+	})
+}

package/go/internal/rlm/rlm.go

@@ -0,0 +1,142 @@
+package rlm
+
+import (
+	"fmt"
+)
+
+type RLM struct {
+	model            string
+	recursiveModel   string
+	apiBase          string
+	apiKey           string
+	maxDepth         int
+	maxIterations    int
+	timeoutSeconds   int
+	useMetacognitive bool
+	extraParams      map[string]interface{}
+	currentDepth     int
+	repl             *REPLExecutor
+	stats            RLMStats
+}
+
+func New(model string, config Config) *RLM {
+	recursiveModel := config.RecursiveModel
+	if recursiveModel == "" {
+		recursiveModel = model
+	}
+
+	return &RLM{
+		model:            model,
+		recursiveModel:   recursiveModel,
+		apiBase:          config.APIBase,
+		apiKey:           config.APIKey,
+		maxDepth:         config.MaxDepth,
+		maxIterations:    config.MaxIterations,
+		timeoutSeconds:   config.TimeoutSeconds,
+		useMetacognitive: config.UseMetacognitive,
+		extraParams:      config.ExtraParams,
+		currentDepth:     0,
+		repl:             NewREPLExecutor(),
+		stats:            RLMStats{},
+	}
+}
+
+func (r *RLM) Completion(query string, context string) (string, RLMStats, error) {
+	if query != "" && context == "" {
+		context = query
+		query = ""
+	}
+
+	if r.currentDepth >= r.maxDepth {
+		return "", r.stats, NewMaxDepthError(r.maxDepth)
+	}
+
+	r.stats.Depth = r.currentDepth
+	replEnv := r.buildREPLEnv(query, context)
+	systemPrompt := BuildSystemPrompt(len(context), r.currentDepth, query, r.useMetacognitive)
+	messages := []Message{
+		{Role: "system", Content: systemPrompt},
+		{Role: "user", Content: query},
+	}
+
+	for iteration := 0; iteration < r.maxIterations; iteration++ {
+		r.stats.Iterations = iteration + 1
+
+		response, err := r.callLLM(messages)
+		if err != nil {
+			return "", r.stats, err
+		}
+
+		if IsFinal(response) {
+			answer, ok := ParseResponse(response, replEnv)
+			if ok {
+				return answer, r.stats, nil
+			}
+		}
+
+		execResult, err := r.repl.Execute(response, replEnv)
+		if err != nil {
+			execResult = fmt.Sprintf("Error: %s", err.Error())
+		}
+
+		messages = append(messages, Message{Role: "assistant", Content: response})
+		messages = append(messages, Message{Role: "user", Content: execResult})
+	}
+
+	return "", r.stats, NewMaxIterationsError(r.maxIterations)
+}
+
+func (r *RLM) callLLM(messages []Message) (string, error) {
+	r.stats.LlmCalls++
+	defaultModel := r.model
+	if r.currentDepth > 0 {
+		defaultModel = r.recursiveModel
+	}
+
+	request := ChatRequest{
+		Model:       defaultModel,
+		Messages:    messages,
+		APIBase:     r.apiBase,
+		APIKey:      r.apiKey,
+		Timeout:     r.timeoutSeconds,
+		ExtraParams: r.extraParams,
+	}
+
+	return CallChatCompletion(request)
+}
+
+func (r *RLM) buildREPLEnv(query string, context string) map[string]interface{} {
+	env := map[string]interface{}{
+		"context": context,
+		"query":   query,
+	}
+
+	env["re"] = NewRegexHelper()
+	env["recursive_llm"] = func(subQuery string, subContext string) string {
+		if r.currentDepth+1 >= r.maxDepth {
+			return fmt.Sprintf("Max recursion depth (%d) reached", r.maxDepth)
+		}
+
+		subConfig := Config{
+			RecursiveModel:   r.recursiveModel,
+			APIBase:          r.apiBase,
+			APIKey:           r.apiKey,
+			MaxDepth:         r.maxDepth,
+			MaxIterations:    r.maxIterations,
+			TimeoutSeconds:   r.timeoutSeconds,
+			UseMetacognitive: r.useMetacognitive,
+			ExtraParams:      r.extraParams,
+		}
+
+		subRLM := New(r.recursiveModel, subConfig)
+		subRLM.currentDepth = r.currentDepth + 1
+
+		answer, _, err := subRLM.Completion(subQuery, subContext)
+		if err != nil {
+			return fmt.Sprintf("Error: %s", err.Error())
+		}
+		return answer
+	}
+
+	return env
+}