@superadnim/rlm-pro 1.0.0

package/README.md

@@ -0,0 +1,139 @@
+# rlm-codebase
+
+Analyze codebases using Recursive Language Models - enables LLMs to handle near-infinite context through recursive decomposition.
+
+Based on the [RLM research](https://arxiv.org/abs/2512.24601) from MIT OASYS lab.
+
+## Installation
+
+```bash
+# Using npx (recommended - no installation needed)
+npx rlm-codebase ./my-project -q "Explain the architecture"
+
+# Or install globally
+npm install -g rlm-codebase
+```
+
+### Prerequisites
+
+- **Node.js 18+**
+- **uv** (Python package manager) - will be prompted to install if missing
+- **OpenAI API key** (set as environment variable)
+
+```bash
+# Install uv if not already installed
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Set your API key
+export OPENAI_API_KEY="your-key"
+```
+
+## Usage
+
+### Command Line
+
+```bash
+# Basic usage
+npx rlm-codebase ./my-project -q "Explain the architecture"
+
+# Get JSON output (for programmatic use)
+npx rlm-codebase ./my-project -q "List all API endpoints" --json
+
+# Use a specific model
+npx rlm-codebase ./my-project -q "Find potential bugs" -m gpt-4o
+
+# Use Anthropic backend
+npx rlm-codebase ./my-project -q "Review this code" -b anthropic
+
+# Verbose output for debugging
+npx rlm-codebase ./my-project -q "How does authentication work?" -v
+
+# Only build context (no LLM call)
+npx rlm-codebase ./my-project -q "" --context-only
+```
+
+### Programmatic Usage (Node.js)
+
+```javascript
+const { analyzeCodebase } = require('rlm-codebase');
+
+async function main() {
+  const result = await analyzeCodebase('./my-project', {
+    query: 'Summarize the codebase structure',
+    backend: 'openai',
+    model: 'gpt-4o',
+  });
+
+  console.log(result.response);
+  console.log('Execution time:', result.execution_time, 'seconds');
+}
+
+main();
+```
+
+## Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `-q, --query <query>` | Question or task to perform (required) | - |
+| `-b, --backend <backend>` | LLM backend (openai, anthropic, etc.) | `openai` |
+| `-m, --model <model>` | Model name | `gpt-4o` |
+| `-e, --env <env>` | Execution environment (local, docker) | `local` |
+| `--max-depth <n>` | Maximum recursion depth | `1` |
+| `--max-iterations <n>` | Maximum iterations | `30` |
+| `--max-file-size <bytes>` | Max size per file | `100000` |
+| `--max-total-size <bytes>` | Max total context size | `500000` |
+| `--no-tree` | Exclude directory tree from context | - |
+| `--json` | Output as JSON | - |
+| `-v, --verbose` | Enable verbose output | - |
+| `--context-only` | Only output built context | - |
+
+## Environment Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| `OPENAI_API_KEY` | OpenAI API key | Yes (for OpenAI backend) |
+| `ANTHROPIC_API_KEY` | Anthropic API key | For Anthropic backend |
+
+## How It Works
+
+RLM (Recursive Language Models) enables LLMs to handle near-infinite context by:
+
+1. **Context Building**: Intelligently reads and formats your codebase
+2. **Recursive Decomposition**: Breaks complex queries into manageable sub-tasks
+3. **Code Execution**: Runs Python code in a sandboxed environment to explore and analyze
+4. **Iterative Refinement**: Continues until a complete answer is found
+
+This allows answering complex questions about large codebases that would exceed normal context limits.
+
+## Examples
+
+### Architecture Analysis
+```bash
+npx rlm-codebase ./backend -q "Describe the system architecture and key design patterns"
+```
+
+### Bug Finding
+```bash
+npx rlm-codebase ./src -q "Find potential security vulnerabilities" --json
+```
+
+### Documentation Generation
+```bash
+npx rlm-codebase ./api -q "Generate API documentation for all endpoints"
+```
+
+### Code Review
+```bash
+npx rlm-codebase ./feature-branch -q "Review this code for best practices"
+```
+
+## License
+
+MIT
+
+## Links
+
+- [RLM Research Paper](https://arxiv.org/abs/2512.24601)
+- [Python Package (PyPI)](https://pypi.org/project/rlm/)
+- [GitHub Repository](https://github.com/mit-oasys/rlm)

package/bin/rlm-codebase.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+/**
+ * RLM Codebase CLI - Node.js wrapper for the Python RLM library
+ *
+ * Analyzes codebases using Recursive Language Models, enabling LLMs
+ * to handle near-infinite context through recursive decomposition.
+ *
+ * Usage:
+ *   npx rlm-codebase ./my-project -q "Explain the architecture"
+ *   npx rlm-codebase ./my-project -q "List all API endpoints" --json
+ */
+
+const { program } = require('commander');
+const { analyzeCodebase, getVersion } = require('../src/index.js');
+
+program
+  .name('rlm-codebase')
+  .description('Analyze codebases using Recursive Language Models')
+  .version('0.1.0')
+  .argument('<path>', 'Path to codebase directory or file')
+  .requiredOption('-q, --query <query>', 'Question or task to perform on the codebase')
+  .option('-b, --backend <backend>', 'LLM backend (openai, anthropic, etc.)', 'openai')
+  .option('-m, --model <model>', 'Model name to use')
+  .option('-e, --env <env>', 'Execution environment (local, docker, modal, prime)', 'local')
+  .option('--max-depth <n>', 'Maximum recursion depth', '1')
+  .option('--max-iterations <n>', 'Maximum iterations', '30')
+  .option('--max-file-size <bytes>', 'Maximum size per file', '100000')
+  .option('--max-total-size <bytes>', 'Maximum total context size', '500000')
+  .option('--no-tree', 'Exclude directory tree from context')
+  .option('--json', 'Output as JSON')
+  .option('-v, --verbose', 'Enable verbose output')
+  .option('--context-only', 'Only output the built context')
+  .action(async (path, options) => {
+    try {
+      const result = await analyzeCodebase(path, options);
+
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else if (options.contextOnly) {
+        console.log(result.context || result.response);
+      } else {
+        console.log(result.response);
+      }
+
+      process.exit(0);
+    } catch (error) {
+      if (options.verbose) {
+        console.error('Error:', error.message);
+        console.error(error.stack);
+      } else {
+        console.error('Error:', error.message);
+      }
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@superadnim/rlm-pro",
+  "version": "1.0.0",
+  "description": "RLM PRO - Enterprise-grade Recursive Language Models for infinite context code analysis. Analyze entire codebases with AI.",
+  "main": "src/index.js",
+  "bin": {
+    "rlm-pro": "./bin/rlm-codebase.js",
+    "rlm-codebase": "./bin/rlm-codebase.js"
+  },
+  "scripts": {
+    "postinstall": "node src/python-manager.js check",
+    "test": "node bin/rlm-codebase.js --version"
+  },
+  "keywords": [
+    "llm",
+    "recursive",
+    "language-model",
+    "codebase",
+    "analysis",
+    "context",
+    "ai",
+    "openai",
+    "anthropic",
+    "claude",
+    "gemini",
+    "enterprise",
+    "code-review",
+    "infinite-context"
+  ],
+  "author": "Columbia Group Labs <labs@columbiagroup.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cg-labs/RLM-PRO.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cg-labs/RLM-PRO/issues"
+  },
+  "homepage": "https://github.com/cg-labs/RLM-PRO#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^12.0.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/executor.js

@@ -0,0 +1,120 @@
+/**
+ * Python process executor for RLM
+ *
+ * Spawns Python processes to run the RLM CLI.
+ * Tries multiple methods: uvx (for published packages), uv run (for local dev),
+ * and direct python (fallback).
+ * Uses execFile for security (avoids shell injection).
+ */
+
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+const fs = require('fs');
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Try to run a command and return result or null if failed.
+ */
+async function tryCommand(cmd, args, options) {
+  try {
+    return await execFileAsync(cmd, args, options);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Run the RLM CLI with the given arguments.
+ * Tries multiple execution methods in order of preference.
+ *
+ * @param {string[]} args - Arguments to pass to rlm-codebase CLI
+ * @returns {Promise<Object>} Parsed JSON result from the CLI
+ */
+async function runRlm(args) {
+  const execOptions = {
+    maxBuffer: 50 * 1024 * 1024, // 50MB buffer for large outputs
+    timeout: 600000, // 10 minute timeout
+    env: {
+      ...process.env,
+      PYTHONIOENCODING: 'utf-8',
+    },
+  };
+
+  let result = null;
+  let lastError = null;
+
+  // Method 1: Try uvx (for published packages on PyPI)
+  result = await tryCommand('uvx', ['rlm', ...args], execOptions);
+
+  // Method 2: Try uv run rlm-codebase (for local development with pyproject.toml)
+  if (!result) {
+    result = await tryCommand('uv', ['run', 'rlm-codebase', ...args], execOptions);
+  }
+
+  // Method 3: Try direct rlm-codebase command (if installed in PATH)
+  if (!result) {
+    result = await tryCommand('rlm-codebase', args, execOptions);
+  }
+
+  // Method 4: Try python -m rlm.cli (fallback)
+  if (!result) {
+    result = await tryCommand('python3', ['-m', 'rlm.cli', ...args], execOptions);
+  }
+
+  // Method 5: Try python -m rlm.cli (Windows fallback)
+  if (!result) {
+    result = await tryCommand('python', ['-m', 'rlm.cli', ...args], execOptions);
+  }
+
+  if (!result) {
+    throw new Error(
+      'Could not run RLM CLI. Please ensure:\n' +
+      '1. uv is installed: curl -LsSf https://astral.sh/uv/install.sh | sh\n' +
+      '2. rlm package is installed: uv pip install rlm\n' +
+      '   Or for local development: cd <rlm-repo> && uv pip install -e .\n' +
+      '3. Restart your terminal after installation'
+    );
+  }
+
+  const { stdout, stderr } = result;
+
+  // Check for API key errors in stderr
+  if (stderr && stderr.includes('API_KEY')) {
+    throw new Error(
+      'API key not configured. Set the appropriate environment variable:\n' +
+      '  export OPENAI_API_KEY="your-key"    # For OpenAI\n' +
+      '  export ANTHROPIC_API_KEY="your-key" # For Anthropic'
+    );
+  }
+
+  // Try to parse as JSON
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    // If not JSON, return as response object
+    return {
+      response: stdout.trim(),
+      stderr: stderr || undefined,
+    };
+  }
+}
+
+/**
+ * Check if the RLM setup is working.
+ * @returns {Promise<boolean>}
+ */
+async function checkSetup() {
+  try {
+    await execFileAsync('uvx', ['rlm-codebase', '--version']);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  runRlm,
+  checkSetup,
+};

package/src/index.js

@@ -0,0 +1,97 @@
+/**
+ * RLM Codebase - Main module
+ *
+ * Provides programmatic access to the RLM codebase analyzer.
+ */
+
+const { runRlm, checkSetup } = require('./executor.js');
+const { checkPythonSetup } = require('./python-manager.js');
+
+/**
+ * Analyze a codebase using Recursive Language Models.
+ *
+ * @param {string} path - Path to codebase directory or file
+ * @param {Object} options - Analysis options
+ * @param {string} options.query - Question or task to perform
+ * @param {string} [options.backend='openai'] - LLM backend
+ * @param {string} [options.model] - Model name
+ * @param {string} [options.env='local'] - Execution environment
+ * @param {string} [options.maxDepth='1'] - Maximum recursion depth
+ * @param {string} [options.maxIterations='30'] - Maximum iterations
+ * @param {string} [options.maxFileSize='100000'] - Max file size
+ * @param {string} [options.maxTotalSize='500000'] - Max total context size
+ * @param {boolean} [options.tree=true] - Include directory tree
+ * @param {boolean} [options.json=false] - Request JSON output
+ * @param {boolean} [options.verbose=false] - Enable verbose output
+ * @param {boolean} [options.contextOnly=false] - Only build context
+ * @returns {Promise<Object>} Analysis result
+ */
+async function analyzeCodebase(path, options = {}) {
+  // Ensure Python/uv is set up
+  await checkPythonSetup();
+
+  // Build arguments for Python CLI
+  const args = [path, '-q', options.query];
+
+  if (options.backend) {
+    args.push('-b', options.backend);
+  }
+
+  if (options.model) {
+    args.push('-m', options.model);
+  }
+
+  if (options.env) {
+    args.push('-e', options.env);
+  }
+
+  if (options.maxDepth) {
+    args.push('--max-depth', options.maxDepth);
+  }
+
+  if (options.maxIterations) {
+    args.push('--max-iterations', options.maxIterations);
+  }
+
+  if (options.maxFileSize) {
+    args.push('--max-file-size', options.maxFileSize);
+  }
+
+  if (options.maxTotalSize) {
+    args.push('--max-total-size', options.maxTotalSize);
+  }
+
+  if (options.tree === false || options.noTree) {
+    args.push('--no-tree');
+  }
+
+  if (options.verbose) {
+    args.push('-v');
+  }
+
+  if (options.contextOnly) {
+    args.push('--context-only');
+  }
+
+  // Always request JSON from Python for parsing
+  args.push('--json');
+
+  // Run the Python CLI
+  const result = await runRlm(args);
+
+  return result;
+}
+
+/**
+ * Get the version of the RLM CLI.
+ * @returns {string} Version string
+ */
+function getVersion() {
+  return '0.1.0';
+}
+
+module.exports = {
+  analyzeCodebase,
+  getVersion,
+  checkSetup,
+};

package/src/python-manager.js

@@ -0,0 +1,128 @@
+/**
+ * Python environment manager for RLM
+ *
+ * Handles checking and setting up Python/uv dependencies.
+ */
+
+const { execFile, execFileSync } = require('child_process');
+const { promisify } = require('util');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Check if uv is installed and available.
+ * @returns {Promise<boolean>}
+ */
+async function checkUv() {
+  try {
+    await execFileAsync('uv', ['--version']);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if uvx can run rlm-codebase.
+ * @returns {Promise<boolean>}
+ */
+async function checkRlmInstalled() {
+  try {
+    await execFileAsync('uvx', ['rlm-codebase', '--version']);
+    return true;
+  } catch {
+    // uvx might not have rlm-codebase cached yet, which is fine
+    return false;
+  }
+}
+
+/**
+ * Get instructions for installing uv.
+ * @returns {string}
+ */
+function getUvInstallInstructions() {
+  const platform = os.platform();
+
+  if (platform === 'win32') {
+    return `
+To install uv (Python package manager):
+  powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
+
+Or with pip:
+  pip install uv
+
+Then restart your terminal and try again.
+`;
+  }
+
+  return `
+To install uv (Python package manager):
+  curl -LsSf https://astral.sh/uv/install.sh | sh
+
+Or with pip:
+  pip install uv
+
+Or with Homebrew (macOS):
+  brew install uv
+
+Then restart your terminal and try again.
+`;
+}
+
+/**
+ * Check Python setup and provide helpful messages.
+ * @returns {Promise<void>}
+ */
+async function checkPythonSetup() {
+  const hasUv = await checkUv();
+
+  if (!hasUv) {
+    console.error('Error: uv (Python package manager) is not installed.');
+    console.error(getUvInstallInstructions());
+    throw new Error('uv is required but not installed');
+  }
+
+  // Check for required API key
+  if (!process.env.OPENAI_API_KEY && !process.env.ANTHROPIC_API_KEY) {
+    console.warn('Warning: No API key found. Set OPENAI_API_KEY or ANTHROPIC_API_KEY environment variable.');
+  }
+}
+
+/**
+ * Check command - run from postinstall
+ */
+function runCheck() {
+  checkUv()
+    .then(hasUv => {
+      if (hasUv) {
+        console.log('RLM Codebase: Python environment ready (uv detected)');
+      } else {
+        console.log('RLM Codebase: uv not detected. Install it to use this tool:');
+        console.log('  curl -LsSf https://astral.sh/uv/install.sh | sh');
+      }
+    })
+    .catch(err => {
+      console.error('RLM Codebase: Setup check failed:', err.message);
+    });
+}
+
+// Handle CLI invocation
+if (require.main === module) {
+  const command = process.argv[2];
+
+  if (command === 'check') {
+    runCheck();
+  } else {
+    console.log('Usage: node python-manager.js check');
+  }
+}
+
+module.exports = {
+  checkUv,
+  checkRlmInstalled,
+  checkPythonSetup,
+  getUvInstallInstructions,
+};