rlm-cli 0.2.20 → 0.2.22

package/dist/cli.js

@@ -77,7 +77,7 @@ function parseArgs() {
         }
     }
     if (!modelId) {
-        modelId = process.env.RLM_MODEL || "claude-sonnet-4-5-20250929";
+        modelId = process.env.RLM_MODEL || "claude-sonnet-4-6";
     }
     if (positional.length === 0) {
         console.error("Error: query argument is required");
@@ -114,16 +114,60 @@ async function fetchUrl(url) {
 // ── Main ────────────────────────────────────────────────────────────────────
 async function main() {
     const args = parseArgs();
-    // Resolve model by scanning all providers (stop at first match)
+    // Provider → env var mapping
+    const providerKeys = {
+        anthropic: "ANTHROPIC_API_KEY", openai: "OPENAI_API_KEY",
+        google: "GEMINI_API_KEY", "google-gemini-cli": "GEMINI_API_KEY",
+        groq: "GROQ_API_KEY", xai: "XAI_API_KEY",
+        mistral: "MISTRAL_API_KEY", openrouter: "OPENROUTER_API_KEY",
+    };
+    const defaultModels = {
+        anthropic: "claude-sonnet-4-6", openai: "gpt-4o",
+        google: "gemini-2.5-flash", groq: "llama-3.3-70b-versatile",
+        xai: "grok-4", mistral: "mistral-large-latest", openrouter: "claude-sonnet-4-6",
+    };
+    // Resolve model — ensure provider has an API key
     let model;
+    let resolvedProvider = "";
     const allModelIds = [];
     for (const provider of getProviders()) {
         const providerModels = getModels(provider);
         for (const m of providerModels) {
             allModelIds.push(m.id);
             if (!model && m.id === args.modelId) {
-                model = m;
+                const key = providerKeys[provider] || `${provider.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+                if (process.env[key]) {
+                    model = m;
+                    resolvedProvider = provider;
+                }
+            }
+        }
+    }
+    // Fallback: if default model's provider has no key, pick one that does
+    if (!model) {
+        for (const [prov, envKey] of Object.entries(providerKeys)) {
+            if (!process.env[envKey])
+                continue;
+            const fallbackId = defaultModels[prov];
+            if (!fallbackId)
+                continue;
+            for (const p of getProviders()) {
+                if (p !== prov)
+                    continue;
+                for (const m of getModels(p)) {
+                    if (m.id === fallbackId) {
+                        model = m;
+                        resolvedProvider = prov;
+                        args.modelId = fallbackId;
+                        console.error(`Note: using ${fallbackId} (${prov}) — set RLM_MODEL to override`);
+                        break;
+                    }
+                }
+                if (model)
+                    break;
             }
+            if (model)
+                break;
         }
     }
     if (!model) {
@@ -134,6 +178,17 @@ async function main() {
     // Load context
     let context;
     if (args.file) {
+        try {
+            const stat = fs.statSync(args.file);
+            if (stat.isDirectory()) {
+                console.error(`Error: "${args.file}" is a directory. Use the interactive mode (\`rlm\`) for directory loading.`);
+                process.exit(1);
+            }
+        }
+        catch (err) {
+            console.error(`Error: could not access "${args.file}": ${err.message}`);
+            process.exit(1);
+        }
         console.error(`Reading context from file: ${args.file}`);
         try {
             context = fs.readFileSync(args.file, "utf-8");

package/dist/env.js

@@ -14,10 +14,13 @@ function loadEnvFile(filePath) {
     if (!fs.existsSync(filePath))
         return;
     const content = fs.readFileSync(filePath, "utf-8");
-    for (const line of content.split("\n")) {
-        const trimmed = line.trim();
+    for (const rawLine of content.split("\n")) {
+        let trimmed = rawLine.trim();
         if (!trimmed || trimmed.startsWith("#"))
             continue;
+        // Strip leading "export " (common in .env files)
+        if (trimmed.startsWith("export "))
+            trimmed = trimmed.slice(7);
         const eqIndex = trimmed.indexOf("=");
         if (eqIndex === -1)
             continue;

package/dist/interactive.js

@@ -1127,11 +1127,32 @@ async function interactive() {
         }
         setupRl.close();
     }
-    // Resolve model
+    // Resolve model — ensure the resolved provider actually has an API key
     const initialResolved = resolveModelWithProvider(currentModelId);
     if (initialResolved) {
-        currentModel = initialResolved.model;
-        currentProviderName = initialResolved.provider;
+        const resolvedKey = providerEnvKey(initialResolved.provider);
+        if (process.env[resolvedKey]) {
+            // Provider has a key — use it
+            currentModel = initialResolved.model;
+            currentProviderName = initialResolved.provider;
+        }
+    }
+    // If default model's provider has no key, fall back to a provider that does
+    if (!currentModel) {
+        const activeProvider = detectProvider();
+        if (activeProvider !== "unknown") {
+            const fallbackModel = getDefaultModelForProvider(activeProvider);
+            if (fallbackModel) {
+                const fallbackResolved = resolveModelWithProvider(fallbackModel);
+                if (fallbackResolved) {
+                    currentModelId = fallbackModel;
+                    currentModel = fallbackResolved.model;
+                    currentProviderName = fallbackResolved.provider;
+                    const label = findSetupProvider(activeProvider)?.name || activeProvider;
+                    console.log(`  ${c.dim}Using ${label} (${currentModelId})${c.reset}`);
+                }
+            }
+        }
     }
     if (!currentModel) {
         console.log(`\n  ${c.red}Model "${currentModelId}" not found.${c.reset}`);

package/dist/viewer.js

@@ -341,13 +341,9 @@ function renderIteration(state) {
     // Scroll indicator at top
     if (from > 0) {
         W(`  ${c.dim}^ scroll up (${from} lines above)${c.reset}\n`);
-        for (let i = from + 1; i < to; i++)
-            W(allLines[i] + "\n");
-    }
-    else {
-        for (let i = from; i < to; i++)
-            W(allLines[i] + "\n");
     }
+    for (let i = from; i < to; i++)
+        W(allLines[i] + "\n");
     if (to < allLines.length) {
         // Replace last visible line with scroll indicator
         W(`  ${c.dim}v scroll down (${allLines.length - to} lines below)${c.reset}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rlm-cli",
-  "version": "0.2.20",
+  "version": "0.2.22",
   "description": "Standalone CLI for Recursive Language Models (RLMs) — implements Algorithm 1 from arXiv:2512.24601",
   "type": "module",
   "bin": {