@cloudwarriors-ai/rlm 0.1.6 → 0.1.7

package/README.md

@@ -1,208 +1,176 @@
 # @cloudwarriors-ai/rlm
 
-Recursive Language Model - Process massive contexts (10M+ tokens) through recursive LLM decomposition.
+Process massive amounts of text with AI - way more than fits in a normal context window.
 
-## Overview
+## What Problem Does This Solve?
 
-RLM enables processing of contexts far larger than typical LLM context windows by:
+LLMs have context limits. Claude can handle ~200K tokens, GPT-4 around 128K. But what if you need to analyze:
+- An entire codebase (500+ files)
+- Years of log files
+- A collection of documents
 
-1. Treating content as Python REPL variables
-2. Having the LLM write code to decompose and process chunks
-3. Recursively calling itself with subsets of context
-4. Aggregating results into a final answer
+You can't just paste it all in. **RLM solves this.**
+
+## How It Works
+
+Instead of trying to cram everything into one prompt, RLM:
+
+1. Gives your data to an LLM as a Python variable
+2. Asks the LLM to write code to analyze it
+3. Runs that code in a safe sandbox
+4. If needed, recursively processes chunks
+
+The LLM becomes a programmer that writes its own analysis tools.
+
+```
+Your huge context (10MB of code)
+              │
+              ▼
+     LLM writes Python to
+     analyze and chunk it
+              │
+              ▼
+      Sandbox runs code
+              │
+              ▼
+         Answer
+```
 
 ## Installation
 
 ```bash
-# From GitHub Packages (requires auth)
 npm install @cloudwarriors-ai/rlm
-
-# Or link locally during development
-npm link /path/to/rlm
 ```
 
-## Quick Start
+**Requirement:** You need an [OpenRouter](https://openrouter.ai) API key.
+
+## Basic Usage
 
 ```typescript
 import { createRLM } from '@cloudwarriors-ai/rlm';
 import fs from 'node:fs';
 
+// Create an RLM instance
 const rlm = createRLM({
   apiKey: process.env.OPENROUTER_API_KEY,
 });
 
+// Query with your massive context
 const result = await rlm.query(
-  fs.readFileSync('./massive-codebase.txt', 'utf-8'),
-  'Find all security vulnerabilities'
+  fs.readFileSync('./huge-codebase.txt', 'utf-8'),
+  'Find all the security vulnerabilities'
 );
 
-console.log(result.answer);
-console.log(`Cost: $${result.usage.costUsd.toFixed(4)}`);
-```
-
-## CLI Usage
-
-```bash
-# Install globally
-npm install -g @cloudwarriors-ai/rlm
-
-# Initialize config
-rlm config init
-rlm config set apiKey YOUR_OPENROUTER_API_KEY
-
-# Run a query
-rlm query --file ./large-file.txt --query "Summarize this document"
-
-# With options
-rlm query \
-  --file ./codebase.txt \
-  --query "Find security issues" \
-  --max-depth 5 \
-  --max-cost 5.00 \
-  --verbose
-```
-
-## Configuration
-
-### Environment Variables
-
-```bash
-OPENROUTER_API_KEY=sk-or-...     # Required
-RLM_MODEL=anthropic/claude-sonnet-4  # Default model
-RLM_MAX_DEPTH=5                   # Max recursion depth
-RLM_MAX_COST_USD=10               # Max cost per session
-RLM_MAX_TOKENS=1000000            # Max total tokens
-RLM_TIMEOUT_SECONDS=300           # Session timeout
-RLM_SANDBOX_MODE=strict           # strict|permissive|disabled
-```
-
-### Config File
-
-Create `~/.rlm/config.json`:
-
-```json
-{
-  "apiKey": "sk-or-...",
-  "model": "anthropic/claude-sonnet-4",
-  "maxRecursionDepth": 5,
-  "maxCostUsd": 10,
-  "maxTokens": 1000000,
-  "timeoutMs": 300000
+// Get the answer
+if (result.success) {
+  console.log(result.answer);
+  console.log(`Cost: $${result.usage.costUsd.toFixed(4)}`);
+} else {
+  console.error('Failed:', result.error);
 }
 ```
 
-## API Reference
-
-### createRLM(options)
-
-Create an RLM service instance.
+## Configuration Options
 
 ```typescript
 const rlm = createRLM({
-  apiKey: 'sk-or-...',
+  // Required
+  apiKey: process.env.OPENROUTER_API_KEY,
+
+  // Optional - defaults shown
   model: 'anthropic/claude-sonnet-4',
+
   config: {
-    maxRecursionDepth: 5,
-    maxCostUsd: 10,
+    maxRecursionDepth: 5,    // How many levels deep it can go
+    maxCostUsd: 10.0,        // Stop if cost exceeds this
+    maxTokens: 1000000,      // Total token budget
+    timeoutMs: 300000,       // 5 minute timeout
   },
 });
 ```
 
-### rlm.query(context, query, config?)
-
-Execute an RLM query.
+## What You Get Back
 
 ```typescript
-const result = await rlm.query(
-  context,  // string or ContextInput
-  'Your question',
-  { maxRecursionDepth: 3 }  // optional overrides
-);
+const result = await rlm.query(context, question);
+
+result.sessionId    // Unique ID for this query
+result.success      // true if it worked
+result.answer       // The LLM's answer
+result.error        // Error message if failed
+result.usage        // Token counts and cost
+result.trace        // Step-by-step execution log
 ```
 
-Returns `RLMResult`:
+## Environment Variables
 
-```typescript
-interface RLMResult {
-  sessionId: string;
-  answer: string;
-  success: boolean;
-  error?: string;
-  trace: ExecutionTrace;
-  usage: ResourceUsage;
-}
-```
+You can also configure via environment:
 
-## Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                         CLI Layer                                │
-│                    (src/cli/)                                    │
-└─────────────────────────────────────────────────────────────────┘
-                              │
-                              ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                     Application Layer                            │
-│                    (src/application/)                            │
-│         RLMService - orchestrates use cases                      │
-└─────────────────────────────────────────────────────────────────┘
-                              │
-                              ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                       Domain Layer                               │
-│                    (src/domain/)                                 │
-│         Pure business logic, types, interfaces                   │
-└─────────────────────────────────────────────────────────────────┘
-                              │
-                              ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                   Infrastructure Layer                           │
-│              (src/infrastructure/)                               │
-│         LLM providers, Python executor, persistence              │
-└─────────────────────────────────────────────────────────────────┘
+```bash
+OPENROUTER_API_KEY=sk-or-...     # Required
+RLM_MODEL=anthropic/claude-sonnet-4
+RLM_MAX_DEPTH=5
+RLM_MAX_COST_USD=10
+RLM_TIMEOUT_SECONDS=300
 ```
 
-## Integration with Hermes
+## Real-World Example
+
+Analyzing an entire codebase:
 
 ```typescript
-// In Hermes project
 import { createRLM } from '@cloudwarriors-ai/rlm';
-import { db } from './db';
-import { eventBus } from './events';
-
-const rlm = createRLM({
-  apiKey: process.env.OPENROUTER_API_KEY,
-  sessionStore: new DrizzleSessionStore(db),
-  eventBus,
-});
-
-// Use in API routes
-app.post('/api/rlm/query', async (req, res) => {
-  const result = await rlm.query(req.body.context, req.body.query);
-  res.json(result);
-});
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+async function analyzeCodebase(dir: string) {
+  // Gather all source files
+  const files = await readdir(dir, { recursive: true });
+  const sourceFiles = files.filter(f => f.endsWith('.ts') || f.endsWith('.js'));
+
+  // Read contents
+  let context = '';
+  for (const file of sourceFiles) {
+    const content = await readFile(join(dir, file), 'utf-8');
+    context += `\n### ${file}\n\`\`\`\n${content}\n\`\`\`\n`;
+  }
+
+  // Analyze with RLM
+  const rlm = createRLM({
+    apiKey: process.env.OPENROUTER_API_KEY,
+  });
+
+  const result = await rlm.query(
+    context,
+    'Analyze this codebase. What are the main components? Any code smells or issues?'
+  );
+
+  return result.answer;
+}
 ```
 
-## Development
+## Error Handling
 
-```bash
-# Install dependencies
-npm install
-
-# Build
-npm run build
-
-# Run tests
-npm test
-
-# Type check
-npm run lint
-
-# Watch mode
-npm run dev
+```typescript
+import { createRLM, LimitExceededError, LLMError } from '@cloudwarriors-ai/rlm';
+
+try {
+  const result = await rlm.query(context, query);
+
+  if (!result.success) {
+    console.error('Query failed:', result.error);
+  }
+} catch (error) {
+  if (error instanceof LimitExceededError) {
+    console.error('Hit a limit:', error.message);
+  } else if (error instanceof LLMError) {
+    console.error('LLM error:', error.message);
+  } else {
+    throw error;
+  }
+}
 ```
 
 ## License
 
-UNLICENSED - Private package for CloudWarriors AI
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudwarriors-ai/rlm",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Recursive Language Model - Process massive contexts through recursive LLM decomposition",
   "type": "module",
   "main": "./dist/index.js",
@@ -45,7 +45,7 @@
     "ai"
   ],
   "author": "CloudWarriors AI",
-  "license": "UNLICENSED",
+  "license": "MIT",
   "publishConfig": {
     "access": "public"
   },