recursive-llm-ts 5.0.1 → 5.0.2

package/go/rlm/repl_test.go

@@ -1,291 +0,0 @@
-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/rlm/schema_test.go

@@ -1,343 +0,0 @@
-package rlm
-
-import (
-	"encoding/json"
-	"testing"
-)
-
-func TestNewSchemaValidator(t *testing.T) {
-	tests := []struct {
-		name    string
-		schema  *JSONSchema
-		wantErr bool
-	}{
-		{
-			name:    "nil schema",
-			schema:  nil,
-			wantErr: true,
-		},
-		{
-			name: "simple string schema",
-			schema: &JSONSchema{
-				Type: "string",
-			},
-			wantErr: false,
-		},
-		{
-			name: "object schema with properties",
-			schema: &JSONSchema{
-				Type: "object",
-				Properties: map[string]*JSONSchema{
-					"name": {Type: "string"},
-					"age":  {Type: "number"},
-				},
-				Required: []string{"name"},
-			},
-			wantErr: false,
-		},
-		{
-			name: "array schema",
-			schema: &JSONSchema{
-				Type: "array",
-				Items: &JSONSchema{
-					Type: "string",
-				},
-			},
-			wantErr: false,
-		},
-		{
-			name: "nested object schema",
-			schema: &JSONSchema{
-				Type: "object",
-				Properties: map[string]*JSONSchema{
-					"address": {
-						Type: "object",
-						Properties: map[string]*JSONSchema{
-							"street": {Type: "string"},
-							"city":   {Type: "string"},
-						},
-						Required: []string{"street", "city"},
-					},
-				},
-				Required: []string{"address"},
-			},
-			wantErr: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			validator, err := NewSchemaValidator(tt.schema)
-			if tt.wantErr {
-				if err == nil {
-					t.Error("expected error but got nil")
-				}
-				return
-			}
-			if err != nil {
-				t.Errorf("unexpected error: %v", err)
-				return
-			}
-			if validator == nil {
-				t.Error("expected non-nil validator")
-			}
-		})
-	}
-}
-
-func TestSchemaValidatorValidate(t *testing.T) {
-	schema := &JSONSchema{
-		Type: "object",
-		Properties: map[string]*JSONSchema{
-			"name": {Type: "string"},
-			"age":  {Type: "number"},
-		},
-		Required: []string{"name"},
-	}
-
-	validator, err := NewSchemaValidator(schema)
-	if err != nil {
-		t.Fatalf("failed to create validator: %v", err)
-	}
-
-	tests := []struct {
-		name    string
-		data    interface{}
-		wantErr bool
-	}{
-		{
-			name: "valid data with all fields",
-			data: map[string]interface{}{
-				"name": "Alice",
-				"age":  float64(30),
-			},
-			wantErr: false,
-		},
-		{
-			name: "valid data with only required fields",
-			data: map[string]interface{}{
-				"name": "Bob",
-			},
-			wantErr: false,
-		},
-		{
-			name: "invalid - missing required field",
-			data: map[string]interface{}{
-				"age": float64(25),
-			},
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := validator.Validate(tt.data)
-			if tt.wantErr && err == nil {
-				t.Error("expected validation error but got nil")
-			}
-			if !tt.wantErr && err != nil {
-				t.Errorf("unexpected validation error: %v", err)
-			}
-		})
-	}
-}
-
-func TestValidateJSON(t *testing.T) {
-	schema := &JSONSchema{
-		Type: "object",
-		Properties: map[string]*JSONSchema{
-			"status": {Type: "string"},
-		},
-		Required: []string{"status"},
-	}
-
-	validator, err := NewSchemaValidator(schema)
-	if err != nil {
-		t.Fatalf("failed to create validator: %v", err)
-	}
-
-	validJSON := `{"status": "ok"}`
-	if err := validator.ValidateJSON([]byte(validJSON)); err != nil {
-		t.Errorf("expected valid JSON to pass: %v", err)
-	}
-
-	invalidJSON := `{"missing": "field"}`
-	if err := validator.ValidateJSON([]byte(invalidJSON)); err == nil {
-		t.Error("expected invalid JSON to fail validation")
-	}
-
-	malformedJSON := `{not valid json`
-	if err := validator.ValidateJSON([]byte(malformedJSON)); err == nil {
-		t.Error("expected malformed JSON to fail")
-	}
-}
-
-func TestJSONSchemaConversion(t *testing.T) {
-	original := &JSONSchema{
-		Type: "object",
-		Properties: map[string]*JSONSchema{
-			"name":  {Type: "string"},
-			"score": {Type: "number"},
-		},
-		Required: []string{"name", "score"},
-	}
-
-	// Convert to Google schema and back
-	googleSchema, err := JSONSchemaToGoogleSchema(original)
-	if err != nil {
-		t.Fatalf("failed to convert to Google schema: %v", err)
-	}
-	if googleSchema == nil {
-		t.Fatal("expected non-nil Google schema")
-	}
-
-	roundTrip, err := GoogleSchemaToJSONSchema(googleSchema)
-	if err != nil {
-		t.Fatalf("failed to convert back: %v", err)
-	}
-	if roundTrip.Type != original.Type {
-		t.Errorf("type mismatch: got %s, want %s", roundTrip.Type, original.Type)
-	}
-}
-
-func TestInferSchemaFromJSON(t *testing.T) {
-	tests := []struct {
-		name         string
-		json         string
-		expectedType string
-	}{
-		{
-			name:         "simple object",
-			json:         `{"name": "Alice", "age": 30}`,
-			expectedType: "object",
-		},
-		{
-			name:         "array",
-			json:         `[1, 2, 3]`,
-			expectedType: "array",
-		},
-		{
-			name:         "string",
-			json:         `"hello"`,
-			expectedType: "string",
-		},
-		{
-			name:         "number",
-			json:         `3.14`,
-			expectedType: "number",
-		},
-		{
-			name:         "integer",
-			json:         `42`,
-			expectedType: "integer",
-		},
-		{
-			name:         "boolean",
-			json:         `true`,
-			expectedType: "boolean",
-		},
-		{
-			name:         "null",
-			json:         `null`,
-			expectedType: "null",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			schema, err := InferSchemaFromJSON([]byte(tt.json))
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if schema.Type != tt.expectedType {
-				t.Errorf("got type %s, want %s", schema.Type, tt.expectedType)
-			}
-		})
-	}
-}
-
-func TestInferSchemaFromJSON_NestedObject(t *testing.T) {
-	jsonData := `{
-		"user": {
-			"name": "Alice",
-			"scores": [95, 87, 92]
-		}
-	}`
-
-	schema, err := InferSchemaFromJSON([]byte(jsonData))
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if schema.Type != "object" {
-		t.Fatalf("expected object, got %s", schema.Type)
-	}
-
-	userProp, ok := schema.Properties["user"]
-	if !ok {
-		t.Fatal("missing 'user' property")
-	}
-	if userProp.Type != "object" {
-		t.Errorf("expected user to be object, got %s", userProp.Type)
-	}
-
-	scoresProp, ok := userProp.Properties["scores"]
-	if !ok {
-		t.Fatal("missing 'scores' property")
-	}
-	if scoresProp.Type != "array" {
-		t.Errorf("expected scores to be array, got %s", scoresProp.Type)
-	}
-}
-
-func TestSchemaJSONRoundTrip(t *testing.T) {
-	// Test that our JSONSchema type serializes/deserializes correctly
-	minLen := 5
-	maxLen := 100
-	min := 1.0
-	max := 10.0
-
-	original := &JSONSchema{
-		Type: "object",
-		Properties: map[string]*JSONSchema{
-			"name": {
-				Type:      "string",
-				MinLength: &minLen,
-				MaxLength: &maxLen,
-			},
-			"score": {
-				Type:    "number",
-				Minimum: &min,
-				Maximum: &max,
-			},
-			"tags": {
-				Type: "array",
-				Items: &JSONSchema{
-					Type: "string",
-					Enum: []string{"a", "b", "c"},
-				},
-			},
-		},
-		Required: []string{"name", "score"},
-	}
-
-	data, err := json.Marshal(original)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	var parsed JSONSchema
-	if err := json.Unmarshal(data, &parsed); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-
-	if parsed.Type != "object" {
-		t.Errorf("type mismatch: got %s", parsed.Type)
-	}
-	if len(parsed.Properties) != 3 {
-		t.Errorf("expected 3 properties, got %d", len(parsed.Properties))
-	}
-	if len(parsed.Required) != 2 {
-		t.Errorf("expected 2 required, got %d", len(parsed.Required))
-	}
-}