recursive-llm-ts 2.0.11 → 3.0.1

package/dist/rlm-bridge.js

@@ -55,6 +55,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PythoniaBridge = void 0;
 const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
 class PythoniaBridge {
     constructor() {
         this.rlmModule = null;
@@ -68,11 +69,13 @@ class PythoniaBridge {
             // Lazy load pythonia to avoid errors in Bun environments
             if (!this.python) {
                 try {
+                    // @ts-ignore - Optional dependency, may not be installed
                     const pythonia = yield Promise.resolve().then(() => __importStar(require('pythonia')));
                     this.python = pythonia.python;
                 }
                 catch (error) {
-                    throw new Error('pythonia is not installed. Install it with: npm install pythonia\n' +
+                    throw new Error('pythonia is not available (Python dependencies removed in v3.0). ' +
+                        'Please use the Go bridge (default) or install pythonia separately: npm install pythonia\n' +
                         'Note: pythonia only works with Node.js runtime, not Bun');
                 }
             }
@@ -82,7 +85,27 @@ class PythoniaBridge {
             const pythonExecutable = String((yield sys.executable) || 'python');
             const pythonCmd = pythonExecutable.includes(' ') ? `"${pythonExecutable}"` : pythonExecutable;
             const pipCmd = `${pythonCmd} -m pip install -e "${pythonPackagePath}"`;
+            const pythonDepsPath = path.join(pythonPackagePath, '.pydeps');
+            const pyprojectPath = path.join(pythonPackagePath, 'pyproject.toml');
+            const dependencySpecifiers = (() => {
+                try {
+                    const pyproject = fs.readFileSync(pyprojectPath, 'utf8');
+                    const depsBlock = pyproject.match(/dependencies\s*=\s*\[[\s\S]*?\]/);
+                    if (!depsBlock)
+                        return [];
+                    return Array.from(depsBlock[0].matchAll(/"([^"]+)"/g), (match) => match[1]);
+                }
+                catch (_a) {
+                    return [];
+                }
+            })();
+            const depsInstallCmd = dependencySpecifiers.length > 0
+                ? `${pythonCmd} -m pip install --upgrade --target "${pythonDepsPath}" ${dependencySpecifiers.map((dep) => `"${dep}"`).join(' ')}`
+                : '';
+            const installCmd = depsInstallCmd || pipCmd;
             const pathList = yield sys.path;
+            fs.mkdirSync(pythonDepsPath, { recursive: true });
+            yield pathList.insert(0, pythonDepsPath);
             yield pathList.insert(0, path.join(pythonPackagePath, 'src'));
             // Try to import rlm, install deps if import fails
             try {
@@ -91,23 +114,23 @@ class PythoniaBridge {
             catch (error) {
                 // If import fails, try installing dependencies
                 if ((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('No module named')) {
-                    console.log('[recursive-llm-ts] Installing Python dependencies (first time only)...');
+                    console.log('[recursive-llm-ts] Installing Python dependencies locally (first time only)...');
                     try {
                         const { execSync } = yield Promise.resolve().then(() => __importStar(require('child_process')));
-                        execSync(pipCmd, { stdio: 'inherit' });
+                        execSync(installCmd, { stdio: 'inherit' });
                         console.log('[recursive-llm-ts] ✓ Python dependencies installed');
                         // Try import again
                         this.rlmModule = yield this.python('rlm');
                     }
                     catch (installError) {
                         throw new Error('Failed to import rlm module after installing dependencies.\n' +
-                            `Manual installation: ${pipCmd}\n` +
+                            `Manual installation: ${installCmd}\n` +
                             `Error: ${installError.message || installError}`);
                     }
                 }
                 else {
                     throw new Error('Failed to import rlm module.\n' +
-                        `Run: ${pipCmd}\n` +
+                        `Run: ${installCmd}\n` +
                         `Original error: ${error.message || error}`);
                 }
             }

package/go/README.md

@@ -0,0 +1,347 @@
+# RLM Go Binary
+
+Go implementation of Recursive Language Models (RLM) based on the [original Python implementation](https://github.com/alexzhang13/rlm).
+
+## Overview
+
+This is a self-contained Go binary that implements the RLM algorithm, allowing language models to process extremely long contexts (100k+ tokens) by storing context as a variable and allowing recursive exploration.
+
+**Key Difference from Python**: Uses JavaScript REPL instead of Python REPL for code execution.
+
+## Building
+
+```bash
+# Build the binary
+go build -o rlm ./cmd/rlm
+
+# Run tests
+go test ./internal/rlm/... -v
+
+# Build with optimization
+go build -ldflags="-s -w" -o rlm ./cmd/rlm
+```
+
+## Usage
+
+The binary accepts JSON input on stdin and returns JSON output on stdout.
+
+### Input Format
+
+```json
+{
+  "model": "gpt-4o-mini",
+  "query": "What are the main themes?",
+  "context": "Your long document here...",
+  "config": {
+    "recursive_model": "gpt-4o-mini",
+    "api_base": "https://api.openai.com/v1",
+    "api_key": "sk-...",
+    "max_depth": 5,
+    "max_iterations": 30,
+    "temperature": 0.7
+  }
+}
+```
+
+### Output Format
+
+```json
+{
+  "result": "The main themes are...",
+  "stats": {
+    "llm_calls": 3,
+    "iterations": 2,
+    "depth": 0
+  }
+}
+```
+
+### Example
+
+```bash
+# Basic usage
+echo '{
+  "model": "gpt-4o-mini",
+  "query": "Summarize this",
+  "context": "Long document...",
+  "config": {
+    "api_key": "sk-..."
+  }
+}' | ./rlm
+
+# With environment variable for API key
+export OPENAI_API_KEY="sk-..."
+echo '{
+  "model": "gpt-4o-mini",
+  "query": "What is this about?",
+  "context": "Document text..."
+}' | ./rlm
+```
+
+## Configuration Options
+
+All fields in `config` are optional and have defaults:
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `recursive_model` | string | Same as `model` | Cheaper model for recursive calls |
+| `api_base` | string | `https://api.openai.com/v1` | API endpoint URL |
+| `api_key` | string | From `OPENAI_API_KEY` env | API key for authentication |
+| `max_depth` | int | 5 | Maximum recursion depth |
+| `max_iterations` | int | 30 | Maximum REPL iterations per call |
+| `temperature` | float | 0.7 | LLM temperature (0-2) |
+| `timeout` | int | 60 | HTTP timeout in seconds |
+
+Any other fields in `config` are passed as extra parameters to the LLM API.
+
+## JavaScript REPL Environment
+
+The LLM can write JavaScript code to explore the context. Available globals:
+
+### Core Variables
+- `context` - The document to analyze (string)
+- `query` - The user's question (string)
+- `recursive_llm(sub_query, sub_context)` - Recursively process sub-context
+
+### String Operations
+```javascript
+context.slice(0, 100)           // First 100 chars
+context.split('\n')             // Split by newline
+context.length                  // String length
+```
+
+### Regex (Python-style API)
+```javascript
+re.findall("ERROR", context)    // Find all matches
+re.search("ERROR", context)     // Find first match
+```
+
+### Built-in Functions
+```javascript
+len(context)                    // Length of string/array
+print("hello")                  // Print output
+console.log("hello")            // Same as print
+```
+
+### JSON
+```javascript
+json.loads('{"key":"value"}')   // Parse JSON
+json.dumps({key: "value"})      // Stringify JSON
+```
+
+### Array Operations
+```javascript
+range(5)                        // [0, 1, 2, 3, 4]
+range(2, 5)                     // [2, 3, 4]
+sorted([3, 1, 2])               // [1, 2, 3]
+sum([1, 2, 3])                  // 6
+min([1, 2, 3])                  // 1
+max([1, 2, 3])                  // 3
+enumerate(['a', 'b'])           // [[0,'a'], [1,'b']]
+zip([1, 2], ['a', 'b'])         // [[1,'a'], [2,'b']]
+any([false, true])              // true
+all([true, true])               // true
+```
+
+### Counting & Grouping
+```javascript
+Counter("hello")                // {h:1, e:1, l:2, o:1}
+defaultdict(() => 0)            // Dict with default values
+```
+
+### Math
+```javascript
+Math.floor(3.7)                 // 3
+Math.ceil(3.2)                  // 4
+Math.max(1, 2, 3)               // 3
+```
+
+### Returning Results
+```javascript
+// Option 1: Direct answer (write as text, not code)
+FINAL("The answer is 42")
+
+// Option 2: Return a variable
+const answer = "The answer is 42"
+FINAL_VAR(answer)
+```
+
+## Supported LLM Providers
+
+Works with any OpenAI-compatible API:
+
+- **OpenAI**: `model: "gpt-4o"`, `model: "gpt-4o-mini"`
+- **Azure OpenAI**: Set custom `api_base`
+- **Ollama**: `api_base: "http://localhost:11434/v1"`, `model: "llama3.2"`
+- **llama.cpp**: `api_base: "http://localhost:8000/v1"`
+- **vLLM**: `api_base: "http://localhost:8000/v1"`
+- Any other OpenAI-compatible endpoint
+
+## Architecture
+
+```
+cmd/rlm/main.go              # CLI entry point (JSON I/O)
+internal/rlm/
+├── rlm.go                   # Core RLM logic
+├── types.go                 # Config and stats types
+├── parser.go                # FINAL() extraction
+├── prompt.go                # System prompt builder
+├── repl.go                  # JavaScript REPL (goja)
+└── openai.go                # OpenAI API client
+```
+
+## Error Handling
+
+Errors are written to stderr with exit code 1:
+
+```bash
+# Missing model
+echo '{"query":"test"}' | ./rlm
+# stderr: Missing model in request payload
+
+# API error
+echo '{
+  "model": "invalid",
+  "query": "test",
+  "context": "test"
+}' | ./rlm 2>&1
+# stderr: LLM request failed (401): ...
+```
+
+## Testing
+
+```bash
+# Run all tests
+go test ./internal/rlm/... -v
+
+# Run specific test
+go test ./internal/rlm -run TestParser -v
+
+# With coverage
+go test ./internal/rlm/... -cover
+
+# Benchmark
+go test ./internal/rlm/... -bench=. -benchmem
+```
+
+## Performance
+
+- **Binary size**: ~15MB (uncompressed), ~5MB (compressed with UPX)
+- **Memory**: ~50MB baseline + context size
+- **Startup**: <10ms
+- **REPL overhead**: ~1-2ms per iteration
+
+## Comparison with Python Implementation
+
+| Feature | Python | Go |
+|---------|--------|-----|
+| **REPL Language** | Python (RestrictedPython) | JavaScript (goja) |
+| **LLM Providers** | 100+ via LiteLLM | OpenAI-compatible only |
+| **Async Support** | ✅ Full async/await | ❌ Synchronous only |
+| **Distribution** | Requires Python runtime | ✅ Single binary |
+| **Startup Time** | ~500ms | ~10ms |
+| **Memory Usage** | ~150MB | ~50MB |
+
+## Known Limitations
+
+1. **JavaScript vs Python**: LLMs are more familiar with Python, may need more iterations
+2. **No async**: Recursive calls are sequential, not parallel
+3. **OpenAI API only**: Doesn't support all LiteLLM providers
+4. **No streaming**: Full response only
+
+## Integration with TypeScript
+
+From Node.js/TypeScript:
+
+```typescript
+import { spawn } from 'child_process';
+
+interface RLMRequest {
+  model: string;
+  query: string;
+  context: string;
+  config?: {
+    api_key?: string;
+    max_depth?: number;
+    max_iterations?: number;
+  };
+}
+
+interface RLMResponse {
+  result: string;
+  stats: {
+    llm_calls: number;
+    iterations: number;
+    depth: number;
+  };
+}
+
+async function callRLM(request: RLMRequest): Promise<RLMResponse> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('./rlm');
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data) => { stdout += data; });
+    proc.stderr.on('data', (data) => { stderr += data; });
+
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(stderr || `Exit code ${code}`));
+      } else {
+        resolve(JSON.parse(stdout));
+      }
+    });
+
+    proc.stdin.write(JSON.stringify(request));
+    proc.stdin.end();
+  });
+}
+
+// Usage
+const result = await callRLM({
+  model: 'gpt-4o-mini',
+  query: 'What is this about?',
+  context: longDocument,
+  config: {
+    api_key: process.env.OPENAI_API_KEY,
+  },
+});
+
+console.log(result.result);
+console.log(`Stats: ${result.stats.llm_calls} LLM calls`);
+```
+
+## Troubleshooting
+
+### "Missing model in request payload"
+Include the `model` field in your JSON input.
+
+### "LLM request failed (401)"
+Check your API key is correct and has sufficient credits.
+
+### "max iterations exceeded"
+Increase `max_iterations` in config, or simplify your query.
+
+### "max recursion depth exceeded"
+Increase `max_depth` in config.
+
+### "Execution error: ReferenceError: xyz is not defined"
+Check the JavaScript syntax. Use `console.log()` not `print()`, or ensure `print()` is available.
+
+## Contributing
+
+1. Write tests for new features
+2. Ensure all tests pass: `go test ./internal/rlm/... -v`
+3. Format code: `go fmt ./...`
+4. Update documentation
+
+## License
+
+MIT License - Same as the original Python implementation
+
+## Acknowledgments
+
+- Based on [Recursive Language Models paper](https://alexzhang13.github.io/blog/2025/rlm/) by Alex Zhang and Omar Khattab (MIT)
+- Original Python implementation: https://github.com/alexzhang13/rlm
+- JavaScript engine: [goja](https://github.com/dop251/goja)

package/go/cmd/rlm/main.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+
+	"recursive-llm-go/internal/rlm"
+)
+
+type requestPayload struct {
+	Model   string                 `json:"model"`
+	Query   string                 `json:"query"`
+	Context string                 `json:"context"`
+	Config  map[string]interface{} `json:"config"`
+}
+
+type responsePayload struct {
+	Result string      `json:"result"`
+	Stats  rlm.RLMStats `json:"stats"`
+}
+
+func main() {
+	input, err := io.ReadAll(os.Stdin)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "Failed to read stdin:", err)
+		os.Exit(1)
+	}
+
+	var req requestPayload
+	if err := json.Unmarshal(input, &req); err != nil {
+		fmt.Fprintln(os.Stderr, "Failed to parse input JSON:", err)
+		os.Exit(1)
+	}
+
+	if req.Model == "" {
+		fmt.Fprintln(os.Stderr, "Missing model in request payload")
+		os.Exit(1)
+	}
+
+	config := rlm.ConfigFromMap(req.Config)
+	engine := rlm.New(req.Model, config)
+
+	result, stats, err := engine.Completion(req.Query, req.Context)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+
+	resp := responsePayload{
+		Result: result,
+		Stats:  stats,
+	}
+
+	payload, err := json.Marshal(resp)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "Failed to encode response JSON:", err)
+		os.Exit(1)
+	}
+
+	fmt.Println(string(payload))
+}

package/go/go.mod

@@ -0,0 +1,12 @@
+module recursive-llm-go
+
+go 1.21
+
+require github.com/dop251/goja v0.0.0-20231027120936-b396bb4c349d
+
+require (
+	github.com/dlclark/regexp2 v1.7.0 // indirect
+	github.com/go-sourcemap/sourcemap v2.1.3+incompatible // indirect
+	github.com/google/pprof v0.0.0-20230207041349-798e818bf904 // indirect
+	golang.org/x/text v0.3.8 // indirect
+)

package/go/go.sum

@@ -0,0 +1,57 @@
+github.com/chzyer/logex v1.2.0/go.mod h1:9+9sk7u7pGNWYMkh0hdiL++6OeibzJccyQU4p4MedaY=
+github.com/chzyer/readline v1.5.0/go.mod h1:x22KAscuvRqlLoK9CsoYsmxoXZMMFVyOl86cAH8qUic=
+github.com/chzyer/test v0.0.0-20210722231415-061457976a23/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
+github.com/dlclark/regexp2 v1.7.0 h1:7lJfhqlPssTb1WQx4yvTHN0uElPEv52sbaECrAQxjAo=
+github.com/dlclark/regexp2 v1.7.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/dop251/goja v0.0.0-20211022113120-dc8c55024d06/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk=
+github.com/dop251/goja v0.0.0-20231027120936-b396bb4c349d h1:wi6jN5LVt/ljaBG4ue79Ekzb12QfJ52L9Q98tl8SWhw=
+github.com/dop251/goja v0.0.0-20231027120936-b396bb4c349d/go.mod h1:QMWlm50DNe14hD7t24KEqZuUdC9sOTy8W6XbCU1mlw4=
+github.com/dop251/goja_nodejs v0.0.0-20210225215109-d91c329300e7/go.mod h1:hn7BA7c8pLvoGndExHudxTDKZ84Pyvv+90pbBjbTz0Y=
+github.com/dop251/goja_nodejs v0.0.0-20211022123610-8dd9abb0616d/go.mod h1:DngW8aVqWbuLRMHItjPUyqdj+HWPvnQe8V8y1nDpIbM=
+github.com/go-sourcemap/sourcemap v2.1.3+incompatible h1:W1iEw64niKVGogNgBN3ePyLFfuisuzeidWPMPWmECqU=
+github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
+github.com/google/pprof v0.0.0-20230207041349-798e818bf904 h1:4/hN5RUoecvl+RmJRE2YxKWtnnQls6rQjjW5oV7qg2U=
+github.com/google/pprof v0.0.0-20230207041349-798e818bf904/go.mod h1:uglQLonpP8qtYCYyzA+8c/9qtqgA3qsXGYqCPKARAFg=
+github.com/ianlancetaylor/demangle v0.0.0-20220319035150-800ac71e25c2/go.mod h1:aYm2/VgdVmcIU8iMfdMvDMsRAQjcfZSKFby6HOFvi/w=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY=
+golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=