recursive-llm-ts 2.0.11 → 3.0.1

package/recursive-llm/src/rlm/prompts.py

@@ -1,50 +0,0 @@
-"""System prompt templates for RLM."""
-
-
-def build_system_prompt(context_size: int, depth: int = 0) -> str:
-    """
-    Build system prompt for RLM.
-
-    Args:
-        context_size: Size of context in characters
-        depth: Current recursion depth
-
-    Returns:
-        System prompt string
-    """
-    # Minimal prompt (paper-style)
-    prompt = f"""You are a Recursive Language Model. You interact with context through a Python REPL environment.
-
-The context is stored in variable `context` (not in this prompt). Size: {context_size:,} characters.
-
-Available in environment:
-- context: str (the document to analyze)
-- query: str (the question: "{"{"}query{"}"}")
-- recursive_llm(sub_query, sub_context) -> str (recursively process sub-context)
-- re: already imported regex module (use re.findall, re.search, etc.)
-
-Write Python code to answer the query. The last expression or print() output will be shown to you.
-
-Examples:
-- print(context[:100])  # See first 100 chars
-- errors = re.findall(r'ERROR', context)  # Find all ERROR
-- count = len(errors); print(count)  # Count and show
-
-When you have the answer, use FINAL("answer") - this is NOT a function, just write it as text.
-
-Depth: {depth}"""
-
-    return prompt
-
-
-def build_user_prompt(query: str) -> str:
-    """
-    Build user prompt.
-
-    Args:
-        query: User's question
-
-    Returns:
-        User prompt string
-    """
-    return query

package/recursive-llm/src/rlm/repl.py

@@ -1,235 +0,0 @@
-"""Safe REPL executor using RestrictedPython."""
-
-import io
-import sys
-from typing import Dict, Any, Optional
-from RestrictedPython import compile_restricted_exec, safe_globals, limited_builtins, utility_builtins
-from RestrictedPython.Guards import guarded_iter_unpack_sequence, safer_getattr
-from RestrictedPython.PrintCollector import PrintCollector
-
-
-class REPLError(Exception):
-    """Error during REPL execution."""
-    pass
-
-
-class REPLExecutor:
-    """Safe Python code executor."""
-
-    def __init__(self, timeout: int = 5, max_output_chars: int = 2000):
-        """
-        Initialize REPL executor.
-
-        Args:
-            timeout: Execution timeout in seconds (not currently enforced)
-            max_output_chars: Maximum characters to return (truncate if longer)
-        """
-        self.timeout = timeout
-        self.max_output_chars = max_output_chars
-
-    def execute(self, code: str, env: Dict[str, Any]) -> str:
-        """
-        Execute Python code in restricted environment.
-
-        Args:
-            code: Python code to execute
-            env: Environment with context, query, recursive_llm, etc.
-
-        Returns:
-            String result of execution (stdout or last expression)
-
-        Raises:
-            REPLError: If code execution fails
-        """
-        # Filter out code blocks if present (LLM might wrap code)
-        code = self._extract_code(code)
-
-        if not code.strip():
-            return "No code to execute"
-
-        # Build restricted globals
-        restricted_globals = self._build_globals(env)
-
-        # Capture stdout
-        old_stdout = sys.stdout
-        sys.stdout = captured_output = io.StringIO()
-
-        try:
-            # Compile with RestrictedPython
-            byte_code = compile_restricted_exec(code)
-
-            if byte_code.errors:
-                raise REPLError(f"Compilation error: {', '.join(byte_code.errors)}")
-
-            # Execute
-            exec(byte_code.code, restricted_globals, env)
-
-            # Get output from stdout
-            output = captured_output.getvalue()
-
-            # Get output from PrintCollector if available
-            if '_print' in env and hasattr(env['_print'], '__call__'):
-                # PrintCollector stores prints in its txt attribute
-                print_collector = env['_print']
-                if hasattr(print_collector, 'txt'):
-                    output += ''.join(print_collector.txt)
-
-            # Check if last line was an expression (try to get its value)
-            # This handles cases like: error_count (should return its value)
-            lines = code.strip().split('\n')
-            if lines:
-                last_line = lines[-1].strip()
-                # If last line is a simple expression (no assignment, no keyword)
-                if last_line and not any(kw in last_line for kw in ['=', 'import', 'def', 'class', 'if', 'for', 'while', 'with']):
-                    try:
-                        # Try to evaluate the last line as expression
-                        result = eval(last_line, restricted_globals, env)
-                        if result is not None:
-                            output += str(result) + '\n'
-                    except:
-                        pass  # Not an expression, ignore
-
-            if not output:
-                return "Code executed successfully (no output)"
-
-            # Truncate output if too long (as per paper: "truncated version of output")
-            if len(output) > self.max_output_chars:
-                truncated = output[:self.max_output_chars]
-                return f"{truncated}\n\n[Output truncated: {len(output)} chars total, showing first {self.max_output_chars}]"
-
-            return output.strip()
-
-        except Exception as e:
-            raise REPLError(f"Execution error: {str(e)}")
-
-        finally:
-            sys.stdout = old_stdout
-
-    def _extract_code(self, text: str) -> str:
-        """
-        Extract code from markdown code blocks if present.
-
-        Args:
-            text: Raw text that might contain code
-
-        Returns:
-            Extracted code
-        """
-        # Check for markdown code blocks
-        if '```python' in text:
-            start = text.find('```python') + len('```python')
-            end = text.find('```', start)
-            if end != -1:
-                return text[start:end].strip()
-
-        if '```' in text:
-            start = text.find('```') + 3
-            end = text.find('```', start)
-            if end != -1:
-                return text[start:end].strip()
-
-        return text
-
-    def _build_globals(self, env: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Build restricted globals for safe execution.
-
-        Args:
-            env: User environment
-
-        Returns:
-            Safe globals dict
-        """
-        restricted_globals = safe_globals.copy()
-        restricted_globals.update(limited_builtins)
-        restricted_globals.update(utility_builtins)
-
-        # Add guards
-        restricted_globals['_iter_unpack_sequence_'] = guarded_iter_unpack_sequence
-        restricted_globals['_getattr_'] = safer_getattr
-        restricted_globals['_getitem_'] = lambda obj, index: obj[index]
-        restricted_globals['_getiter_'] = iter
-        restricted_globals['_print_'] = PrintCollector
-
-        # Add additional safe builtins
-        restricted_globals.update({
-            # Types
-            'len': len,
-            'str': str,
-            'int': int,
-            'float': float,
-            'bool': bool,
-            'list': list,
-            'dict': dict,
-            'tuple': tuple,
-            'set': set,
-            'frozenset': frozenset,
-            'bytes': bytes,
-            'bytearray': bytearray,
-
-            # Iteration
-            'range': range,
-            'enumerate': enumerate,
-            'zip': zip,
-            'map': map,
-            'filter': filter,
-            'reversed': reversed,
-            'iter': iter,
-            'next': next,
-
-            # Aggregation
-            'sorted': sorted,
-            'sum': sum,
-            'min': min,
-            'max': max,
-            'any': any,
-            'all': all,
-
-            # Math
-            'abs': abs,
-            'round': round,
-            'pow': pow,
-            'divmod': divmod,
-
-            # String/repr
-            'chr': chr,
-            'ord': ord,
-            'hex': hex,
-            'oct': oct,
-            'bin': bin,
-            'repr': repr,
-            'ascii': ascii,
-            'format': format,
-
-            # Type checking
-            'isinstance': isinstance,
-            'issubclass': issubclass,
-            'callable': callable,
-            'type': type,
-            'hasattr': hasattr,
-
-            # Constants
-            'True': True,
-            'False': False,
-            'None': None,
-        })
-
-        # Add safe standard library modules
-        # These are read-only and don't allow file/network access
-        import re
-        import json
-        import math
-        from datetime import datetime, timedelta
-        from collections import Counter, defaultdict
-
-        restricted_globals.update({
-            're': re,               # Regex (read-only)
-            'json': json,           # JSON parsing (read-only)
-            'math': math,           # Math functions
-            'datetime': datetime,   # Date parsing
-            'timedelta': timedelta, # Time deltas
-            'Counter': Counter,     # Counting helper
-            'defaultdict': defaultdict,  # Dict with defaults
-        })
-
-        return restricted_globals

package/recursive-llm/src/rlm/types.py

@@ -1,37 +0,0 @@
-"""Type definitions for RLM."""
-
-from typing import TypedDict, Optional, Any, Callable, Awaitable
-
-
-class Message(TypedDict):
-    """LLM message format."""
-    role: str
-    content: str
-
-
-class RLMConfig(TypedDict, total=False):
-    """Configuration for RLM instance."""
-    model: str
-    recursive_model: Optional[str]
-    api_base: Optional[str]
-    api_key: Optional[str]
-    max_depth: int
-    max_iterations: int
-    temperature: float
-    timeout: int
-
-
-class REPLEnvironment(TypedDict, total=False):
-    """REPL execution environment."""
-    context: str
-    query: str
-    recursive_llm: Callable[[str, str], Awaitable[str]]
-    re: Any  # re module
-
-
-class CompletionResult(TypedDict):
-    """Result from RLM completion."""
-    answer: str
-    iterations: int
-    depth: int
-    llm_calls: int

package/scripts/install-python-deps.js

@@ -1,72 +0,0 @@
-#!/usr/bin/env node
-const { execSync, execFileSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-
-const pythonPackagePath = path.join(__dirname, '..', 'recursive-llm');
-const pyprojectPath = path.join(pythonPackagePath, 'pyproject.toml');
-
-// Check if pyproject.toml exists
-if (!fs.existsSync(pyprojectPath)) {
-  console.warn('[recursive-llm-ts] Warning: pyproject.toml not found at', pyprojectPath);
-  console.warn('[recursive-llm-ts] Python dependencies will need to be installed manually');
-  process.exit(0); // Don't fail the install
-}
-
-console.log('[recursive-llm-ts] Installing Python dependencies...');
-
-try {
-  const pythonCandidates = [];
-  if (process.env.PYTHON) {
-    pythonCandidates.push({ command: process.env.PYTHON, args: [] });
-  }
-  if (process.platform === 'win32') {
-    pythonCandidates.push({ command: 'py', args: ['-3'] });
-    pythonCandidates.push({ command: 'python', args: [] });
-    pythonCandidates.push({ command: 'python3', args: [] });
-  } else {
-    pythonCandidates.push({ command: 'python3', args: [] });
-    pythonCandidates.push({ command: 'python', args: [] });
-  }
-
-  let pythonCmd = null;
-  for (const candidate of pythonCandidates) {
-    try {
-      execFileSync(candidate.command, [...candidate.args, '--version'], { stdio: 'pipe' });
-      pythonCmd = candidate;
-      break;
-    } catch {
-      // Try next candidate
-    }
-  }
-
-  if (pythonCmd) {
-    execFileSync(
-      pythonCmd.command,
-      [...pythonCmd.args, '-m', 'pip', 'install', '-e', pythonPackagePath],
-      { stdio: 'inherit', cwd: pythonPackagePath }
-    );
-  } else {
-    // Fall back to pip/pip3 if a Python executable wasn't found
-    try {
-      execSync('pip --version', { stdio: 'pipe' });
-    } catch {
-      execSync('pip3 --version', { stdio: 'pipe' });
-    }
-    const pipCommand = process.platform === 'win32'
-      ? `pip install -e "${pythonPackagePath}"`
-      : `pip install -e "${pythonPackagePath}" || pip3 install -e "${pythonPackagePath}"`;
-    execSync(pipCommand, {
-      stdio: 'inherit',
-      cwd: pythonPackagePath
-    });
-  }
-  console.log('[recursive-llm-ts] ✓ Python dependencies installed successfully');
-} catch (error) {
-  console.warn('[recursive-llm-ts] Warning: Failed to auto-install Python dependencies');
-  console.warn('[recursive-llm-ts] This is not critical - you can install them manually:');
-  console.warn(`[recursive-llm-ts]   cd node_modules/recursive-llm-ts/recursive-llm && python -m pip install -e .`);
-  console.warn('[recursive-llm-ts] Or ensure Python 3.9+ and pip are in your PATH');
-  // Don't fail the npm install - exit with 0
-  process.exit(0);
-}