@ruvnet/open-claude-code 2.0.1 → 2.1.1

package/src/config/settings.mjs

@@ -3,7 +3,6 @@
  *
  * Supports all 76 properties from Claude Code's settings schema.
  * Five-layer hierarchy: user > project > local > managed > feature flags.
- * Deep merge with source tracking and write-back.
  */
 import fs from 'fs';
 import path from 'path';
@@ -59,103 +58,34 @@ export const SETTINGS_SCHEMA = {
     agentId: null,
     cronEnabled: true,
     featureFlags: {},
+    // Metaharness self-optimization (opt-in; default OFF — behavior unchanged).
+    selfOptimize: false,
+    selfOptimizeQualityBar: 0.7,
+    selfOptimizeLadder: null,
 };
 
-/** Sources in load order (first = lowest priority, last = highest) */
-const SCOPE_NAMES = ['managed', 'user', 'project', 'local'];
-
-/**
- * Get file paths for each settings scope.
- * @param {string} [cwd]
- * @returns {Record<string, string>}
- */
-export function getSettingsPaths(cwd = process.cwd()) {
-    return {
-        user: path.join(os.homedir(), '.claude', 'settings.json'),
-        project: path.join(cwd, '.claude', 'settings.json'),
-        local: path.join(cwd, '.claude', 'settings.local.json'),
-        managed: path.join(os.homedir(), '.claude', 'settings.managed.json'),
-    };
-}
-
-/**
- * Load settings with 4-source deep merge and source tracking.
- * Order: defaults -> managed -> user -> project -> local -> env overrides
- * @param {string} [cwd]
- * @returns {Promise<object>} merged settings with _sources metadata
- */
-export async function loadSettings(cwd) {
-    const paths = getSettingsPaths(cwd);
+export async function loadSettings() {
     const chain = [
-        { scope: 'managed', file: paths.managed },
-        { scope: 'user', file: paths.user },
-        { scope: 'project', file: paths.project },
-        { scope: 'local', file: paths.local },
+        path.join(os.homedir(), '.claude', 'settings.json'),
+        path.join(process.cwd(), '.claude', 'settings.json'),
+        path.join(process.cwd(), '.claude', 'settings.local.json'),
     ];
 
     let merged = deepClone(SETTINGS_SCHEMA);
-    const sources = {};
 
-    // Track defaults
-    trackSources(sources, SETTINGS_SCHEMA, 'default', '');
-
-    for (const { scope, file } of chain) {
+    for (const file of chain) {
         try {
             const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
             merged = deepMerge(merged, data);
-            trackSources(sources, data, scope, '');
         } catch {
-            // File not found or invalid — skip
+            // File not found or invalid
         }
     }
 
-    applyEnvOverrides(merged, sources);
-
-    // Attach metadata (non-enumerable so it does not interfere with tests)
-    Object.defineProperty(merged, '_sources', { value: sources, enumerable: false, writable: true });
-    Object.defineProperty(merged, '_paths', { value: paths, enumerable: false, writable: true });
-
+    applyEnvOverrides(merged);
     return merged;
 }
 
-/**
- * Save a single setting back to the correct scope file.
- * @param {'user'|'project'|'local'} scope
- * @param {string} key — dot-separated path (e.g. "permissions.defaultMode")
- * @param {*} value
- * @param {string} [cwd]
- */
-export function saveSettings(scope, key, value, cwd) {
-    const paths = getSettingsPaths(cwd);
-    const file = paths[scope];
-    if (!file) throw new Error(`Unknown scope: ${scope}`);
-
-    let existing = {};
-    try {
-        existing = JSON.parse(fs.readFileSync(file, 'utf-8'));
-    } catch {
-        // New file
-    }
-
-    setNestedValue(existing, key, value);
-
-    const dir = path.dirname(file);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(file, JSON.stringify(existing, null, 2) + '\n');
-}
-
-/**
- * Get the source scope for a specific setting key.
- * @param {object} settings — settings object returned by loadSettings
- * @param {string} key — dot-separated path
- * @returns {string} scope name ('default', 'user', 'project', 'local', 'managed', 'env')
- */
-export function getSettingSource(settings, key) {
-    return settings._sources?.[key] || 'default';
-}
-
-// ---------- Helpers ----------
-
 function deepClone(obj) {
     return JSON.parse(JSON.stringify(obj));
 }
@@ -163,8 +93,7 @@ function deepClone(obj) {
 function deepMerge(target, source) {
     const result = { ...target };
     for (const [key, value] of Object.entries(source)) {
-        if (value && typeof value === 'object' && !Array.isArray(value)
-            && typeof result[key] === 'object' && !Array.isArray(result[key])) {
+        if (value && typeof value === 'object' && !Array.isArray(value) && typeof result[key] === 'object' && !Array.isArray(result[key])) {
             result[key] = deepMerge(result[key] || {}, value);
         } else {
             result[key] = value;
@@ -173,53 +102,24 @@ function deepMerge(target, source) {
     return result;
 }
 
-function trackSources(sources, obj, scope, prefix) {
-    for (const [key, value] of Object.entries(obj)) {
-        const fullKey = prefix ? `${prefix}.${key}` : key;
-        sources[fullKey] = scope;
-        if (value && typeof value === 'object' && !Array.isArray(value)) {
-            trackSources(sources, value, scope, fullKey);
-        }
-    }
-}
-
-function setNestedValue(obj, key, value) {
-    const parts = key.split('.');
-    let cur = obj;
-    for (let i = 0; i < parts.length - 1; i++) {
-        if (!cur[parts[i]] || typeof cur[parts[i]] !== 'object') {
-            cur[parts[i]] = {};
-        }
-        cur = cur[parts[i]];
+function applyEnvOverrides(settings) {
+    if (process.env.ANTHROPIC_MODEL) settings.model = process.env.ANTHROPIC_MODEL;
+    if (process.env.CLAUDE_CODE_SUBAGENT_MODEL) settings.subagentModel = process.env.CLAUDE_CODE_SUBAGENT_MODEL;
+    if (process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS) {
+        const n = parseInt(process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS, 10);
+        if (!isNaN(n)) { settings.maxOutputTokens = n; settings.maxTokens = n; }
     }
-    cur[parts[parts.length - 1]] = value;
-}
-
-function applyEnvOverrides(settings, sources) {
-    const envMap = [
-        ['ANTHROPIC_MODEL', (v) => { settings.model = v; }, 'model'],
-        ['CLAUDE_CODE_SUBAGENT_MODEL', (v) => { settings.subagentModel = v; }, 'subagentModel'],
-        ['CLAUDE_CODE_MAX_OUTPUT_TOKENS', (v) => {
-            const n = parseInt(v, 10);
-            if (!isNaN(n)) { settings.maxOutputTokens = n; settings.maxTokens = n; }
-        }, 'maxOutputTokens'],
-        ['CLAUDE_CODE_MAX_CONTEXT_TOKENS', (v) => {
-            const n = parseInt(v, 10);
-            if (!isNaN(n)) settings.maxContextTokens = n;
-        }, 'maxContextTokens'],
-        ['CLAUDE_CODE_BRIEF', (v) => { if (v === '1') settings.briefMode = true; }, 'briefMode'],
-        ['CLAUDE_CODE_DEBUG', (v) => { if (v === '1') settings.debugMode = true; }, 'debugMode'],
-        ['CLAUDE_CODE_PERMISSION_MODE', (v) => { settings.permissions.defaultMode = v; }, 'permissions.defaultMode'],
-        ['CLAUDE_CODE_STREAMING', (v) => { if (v === '0') settings.stream = false; }, 'stream'],
-        ['CLAUDE_CODE_THINKING', (v) => { if (v === '1') settings.alwaysThinkingEnabled = true; }, 'alwaysThinkingEnabled'],
-        ['CLAUDE_CODE_DISABLE_CRON', (v) => { if (v === '1') settings.cronEnabled = false; }, 'cronEnabled'],
-        ['CLAUDE_CODE_ENABLE_TASKS', (v) => { if (v === '1') settings.enableTeams = true; }, 'enableTeams'],
-    ];
-
-    for (const [envKey, apply, settingsKey] of envMap) {
-        if (process.env[envKey]) {
-            apply(process.env[envKey]);
-            if (sources) sources[settingsKey] = 'env';
-        }
+    if (process.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS) {
+        const n = parseInt(process.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS, 10);
+        if (!isNaN(n)) settings.maxContextTokens = n;
     }
+    if (process.env.CLAUDE_CODE_BRIEF === '1') settings.briefMode = true;
+    if (process.env.CLAUDE_CODE_DEBUG === '1') settings.debugMode = true;
+    if (process.env.CLAUDE_CODE_PERMISSION_MODE) settings.permissions.defaultMode = process.env.CLAUDE_CODE_PERMISSION_MODE;
+    if (process.env.CLAUDE_CODE_STREAMING === '0') settings.stream = false;
+    if (process.env.CLAUDE_CODE_THINKING === '1') settings.alwaysThinkingEnabled = true;
+    if (process.env.CLAUDE_CODE_DISABLE_CRON === '1') settings.cronEnabled = false;
+    if (process.env.CLAUDE_CODE_ENABLE_TASKS === '1') settings.enableTeams = true;
+    if (process.env.CLAUDE_CODE_SELF_OPTIMIZE === '1') settings.selfOptimize = true;
+    if (process.env.CLAUDE_CODE_SELF_OPTIMIZE === '0') settings.selfOptimize = false;
 }

package/src/core/agent-loop.mjs

@@ -5,9 +5,12 @@
 import { streamResponse, accumulateStream } from './streaming.mjs';
 import { ContextManager } from './context-manager.mjs';
 import { buildSystemPrompt } from './system-prompt.mjs';
-import fs from 'fs';
-import path from 'path';
-export function createAgentLoop({ model, tools, permissions, settings, hooks }) {
+import { readApiKey } from './providers.mjs';
+
+/** Maximum number of consecutive tool-use continuation turns before aborting. */
+const MAX_TOOL_RECURSION_DEPTH = 50;
+
+export function createAgentLoop({ model, tools, permissions, settings, hooks, cascade = null }) {
     const contextManager = new ContextManager(settings.maxContextTokens || 180000);
 
     // Build system prompt using the new builder
@@ -26,9 +29,41 @@ export function createAgentLoop({ model, tools, permissions, settings, hooks })
         model,
         tools,
         _contextManager: contextManager,
+        _cascade: cascade,
     };
 
+    // Self-optimization bookkeeping for the current top-level task (opt-in).
+    let _optTask = null; // { model, complexity, startedAt, tokensAtStart }
+
+    /** Record the outcome of the current task, if self-optimization is on. */
+    function recordOptOutcome(success) {
+        if (!cascade || !_optTask) return;
+        const inputDelta = state.tokenUsage.input - _optTask.tokensAtStart.input;
+        const outputDelta = state.tokenUsage.output - _optTask.tokensAtStart.output;
+        try {
+            cascade.recordOutcome({
+                model: _optTask.model,
+                success,
+                latencyMs: Date.now() - _optTask.startedAt,
+                inputTokens: inputDelta >= 0 ? inputDelta : 0,
+                outputTokens: outputDelta >= 0 ? outputDelta : 0,
+                complexity: _optTask.complexity,
+                task: _optTask.task,
+            });
+        } catch { /* best-effort */ }
+        _optTask = null;
+    }
+
     async function* run(userMessage, options = {}) {
+        const depth = (options._depth || 0);
+
+        // Guard against runaway tool-call recursion
+        if (depth >= MAX_TOOL_RECURSION_DEPTH) {
+            yield { type: 'error', message: `Max tool recursion depth (${MAX_TOOL_RECURSION_DEPTH}) reached. Stopping to prevent infinite loop.` };
+            yield { type: 'stop', reason: 'max_recursion' };
+            return;
+        }
+
         // Add user message (skip for continuation turns)
         if (userMessage && !options.continuation) {
             state.messages = contextManager.addMessage(state.messages, {
@@ -36,6 +71,22 @@ export function createAgentLoop({ model, tools, permissions, settings, hooks })
                 content: userMessage,
             });
             state.turnCount++;
+
+            // Opt-in cost-cascade routing: pick the cheapest good-enough model
+            // for this task and record outcome bookkeeping. Default path (no
+            // cascade) leaves state.model exactly as constructed.
+            if (cascade) {
+                const route = cascade.decide(userMessage);
+                state.model = route.model;
+                state._lastRoute = route;
+                _optTask = {
+                    model: route.model,
+                    complexity: route.complexity,
+                    startedAt: Date.now(),
+                    tokensAtStart: { input: state.tokenUsage.input, output: state.tokenUsage.output },
+                    task: String(userMessage).slice(0, 120),
+                };
+            }
         }
 
         // Check max turns
@@ -53,14 +104,16 @@ export function createAgentLoop({ model, tools, permissions, settings, hooks })
 
         yield { type: 'stream_request_start', turn: state.turnCount };
 
-        // Detect provider and call API
-        const provider = detectProvider(model);
+        // Detect provider and call API. Use state.model so an opt-in cascade
+        // pick takes effect; defaults to the constructed model otherwise.
+        const activeModel = state.model || model;
+        const provider = detectProvider(activeModel);
         let response;
 
         try {
-            if (settings.stream !== false) {
+            if (settings.stream !== false && provider === 'anthropic') {
                 // Streaming mode
-                response = await callApiStreaming(provider, model, state, tools.list(), settings);
+                response = await callApiStreaming(provider, activeModel, state, tools.list(), settings);
                 const collectedContent = [];
                 let currentText = '';
                 let currentThinking = '';
@@ -87,9 +140,10 @@ export function createAgentLoop({ model, tools, permissions, settings, hooks })
                 response = response.accumulated;
             } else {
                 // Non-streaming mode
-                response = await callApi(provider, model, state, tools.list(), settings);
+                response = await callApi(provider, activeModel, state, tools.list(), settings);
             }
         } catch (err) {
+            recordOptOutcome(false);
             yield { type: 'error', message: err.message };
             return;
         }
@@ -180,7 +234,7 @@ export function createAgentLoop({ model, tools, permissions, settings, hooks })
             state.messages.push({ role: 'user', content: toolResults });
 
             // Recursive: continue the loop after tool execution
-            yield* run(null, { continuation: true });
+            yield* run(null, { continuation: true, _depth: depth + 1 });
             return;
         }
 
@@ -193,11 +247,14 @@ export function createAgentLoop({ model, tools, permissions, settings, hooks })
                     role: 'user',
                     content: '[System: A hook prevented stopping. Please continue with the task.]',
                 });
-                yield* run(null, { continuation: true });
+                yield* run(null, { continuation: true, _depth: depth + 1 });
                 return;
             }
         }
 
+        // Task completed normally — record a successful outcome (opt-in).
+        recordOptOutcome(true);
+
         yield { type: 'stop', reason: response.stop_reason || 'end_turn' };
     }
 
@@ -223,8 +280,8 @@ async function callApiStreaming(provider, model, state, toolDefs, settings) {
 }
 
 async function callAnthropic(model, state, toolDefs, settings, stream) {
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) throw new Error('ANTHROPIC_API_KEY not set');
+    const apiKey = readApiKey('ANTHROPIC_API_KEY');
+    if (!apiKey) throw new Error('ANTHROPIC_API_KEY is not set. Export it in your environment before running.');
 
     const body = {
         model,
@@ -240,7 +297,8 @@ async function callAnthropic(model, state, toolDefs, settings, stream) {
         body.thinking = { type: 'enabled', budget_tokens: settings.thinkingBudget || 10000 };
     }
 
-    const res = await fetch('https://api.anthropic.com/v1/messages', {
+    const res = await fetch((process.env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com').replace(/\/$/, '') + '/v1/messages', {
+        redirect: 'error',
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
@@ -252,7 +310,7 @@ async function callAnthropic(model, state, toolDefs, settings, stream) {
 
     if (!res.ok) {
         const err = await res.text();
-        throw new Error(`Anthropic API error ${res.status}: ${err}`);
+        throw new Error(`Anthropic API error ${res.status}`);
     }
 
     if (stream) {
@@ -275,24 +333,29 @@ async function callAnthropic(model, state, toolDefs, settings, stream) {
 }
 
 async function callOpenAI(model, state, toolDefs, settings, stream) {
-    const apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey) throw new Error('OPENAI_API_KEY not set');
+    const apiKey = readApiKey('OPENAI_API_KEY');
+    if (!apiKey) throw new Error('OPENAI_API_KEY is not set. Export it in your environment before running.');
 
     const messages = [];
-    if (state.systemPrompt) {
-        messages.push({ role: 'system', content: state.systemPrompt });
-    }
+    if (state.systemPrompt) messages.push({ role: 'system', content: state.systemPrompt });
     for (const msg of state.messages) {
         if (typeof msg.content === 'string') {
             messages.push({ role: msg.role, content: msg.content });
         } else if (Array.isArray(msg.content)) {
-            for (const block of msg.content) {
-                if (block.type === 'tool_result') {
-                    messages.push({
-                        role: 'tool',
+            if (msg.role === 'assistant') {
+                const calls = msg.content.filter(b => b.type === 'tool_use').map(b => ({
+                    id: b.id, type: 'function',
+                    function: { name: b.name, arguments: JSON.stringify(b.input || {}) }
+                }));
+                messages.push({ role: 'assistant',
+                    content: msg.content.filter(b => b.type === 'text').map(b => b.text).join('') || null,
+                    ...(calls.length && { tool_calls: calls }) });
+            } else {
+                for (const block of msg.content) {
+                    if (block.type === 'tool_result') messages.push({ role: 'tool',
                         tool_call_id: block.tool_use_id,
-                        content: block.content,
-                    });
+                        content: typeof block.content === 'string' ? block.content : JSON.stringify(block.content) });
+                    else if (block.type === 'text') messages.push({ role: msg.role, content: block.text });
                 }
             }
         }
@@ -311,6 +374,7 @@ async function callOpenAI(model, state, toolDefs, settings, stream) {
 
     const baseUrl = process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1';
     const res = await fetch(`${baseUrl}/chat/completions`, {
+        redirect: 'error',
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
@@ -321,7 +385,7 @@ async function callOpenAI(model, state, toolDefs, settings, stream) {
 
     if (!res.ok) {
         const err = await res.text();
-        throw new Error(`OpenAI API error ${res.status}: ${err}`);
+        throw new Error(`OpenAI API error ${res.status}`);
     }
 
     const data = await res.json();
@@ -329,8 +393,8 @@ async function callOpenAI(model, state, toolDefs, settings, stream) {
 }
 
 async function callGoogle(model, state, toolDefs, settings, stream) {
-    const apiKey = process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY;
-    if (!apiKey) throw new Error('GOOGLE_API_KEY or GEMINI_API_KEY not set');
+    const apiKey = readApiKey('GOOGLE_API_KEY', 'GEMINI_API_KEY');
+    if (!apiKey) throw new Error('GOOGLE_API_KEY or GEMINI_API_KEY is not set. Export one in your environment before running.');
 
     const contents = [];
     for (const msg of state.messages) {

package/src/core/providers.mjs

@@ -204,6 +204,24 @@ export function listProviders() {
     }));
 }
 
+/**
+ * Read an API key from the environment, in order of preference.
+ *
+ * Surrounding whitespace is trimmed — keys routinely arrive from .env files or
+ * command substitution with a trailing newline — and a whitespace-only value is
+ * treated as unset, so the next name is tried. No format validation: the
+ * provider is what authenticates the key.
+ * @param {...string} envKeys - env var names to try, most preferred first
+ * @returns {string} the trimmed key, or '' if none is configured
+ */
+export function readApiKey(...envKeys) {
+    for (const envKey of envKeys) {
+        const value = (process.env[envKey] || '').trim();
+        if (value) return value;
+    }
+    return '';
+}
+
 /**
  * Check which providers have API keys configured.
  * @returns {Array<{ id: string, name: string, configured: boolean }>}
@@ -212,7 +230,7 @@ export function checkProviderKeys() {
     return Object.entries(PROVIDERS).map(([key, p]) => ({
         id: key,
         name: p.name,
-        configured: !!(process.env[p.envKey] || (p.altEnvKey && process.env[p.altEnvKey])),
+        configured: !!readApiKey(p.envKey, ...(p.altEnvKey ? [p.altEnvKey] : [])),
     }));
 }