@ruvnet/open-claude-code 2.0.0

package/src/core/context-manager.mjs

@@ -0,0 +1,198 @@
+/**
+ * Context Manager — tracks token usage and compacts conversation history.
+ *
+ * Features:
+ * - Proper token estimation (4 chars ~ 1 token for English)
+ * - Micro-compaction (remove stale tool results older than 5 turns)
+ * - Keep system prompt and recent 3 turns intact during compaction
+ * - Track pre/post compaction token counts
+ */
+
+const DEFAULT_MAX_TOKENS = 180000; // ~200k model limit with buffer
+const COMPACT_THRESHOLD = 0.80;
+const CHARS_PER_TOKEN = 4; // rough estimate for English text
+const STALE_TOOL_RESULT_TURNS = 5; // tool results older than this are micro-compacted
+
+export class ContextManager {
+    /**
+     * @param {number} maxTokens - Maximum tokens for context window
+     */
+    constructor(maxTokens = DEFAULT_MAX_TOKENS) {
+        this.maxTokens = maxTokens;
+        this.threshold = COMPACT_THRESHOLD;
+        this.compactionCount = 0;
+        this.lastPreCompactTokens = 0;
+        this.lastPostCompactTokens = 0;
+    }
+
+    /**
+     * Estimate token count for a message array.
+     * Uses character-based heuristic (no external tokenizer dependency).
+     * @param {Array} messages - conversation messages
+     * @returns {number} estimated token count
+     */
+    getTokenCount(messages) {
+        let chars = 0;
+        for (const msg of messages) {
+            // Role overhead (~4 tokens)
+            chars += 16;
+
+            if (typeof msg.content === 'string') {
+                chars += msg.content.length;
+            } else if (Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === 'text') chars += (block.text || '').length;
+                    else if (block.type === 'tool_result') chars += (block.content || '').length;
+                    else if (block.type === 'tool_use') chars += JSON.stringify(block.input || {}).length + 20;
+                    else if (block.type === 'thinking') chars += (block.thinking || '').length;
+                    else chars += JSON.stringify(block).length;
+                }
+            }
+        }
+        return Math.ceil(chars / CHARS_PER_TOKEN);
+    }
+
+    /**
+     * Check if compaction is needed.
+     * @param {Array} messages - current conversation messages
+     * @returns {boolean}
+     */
+    shouldCompact(messages) {
+        const tokenCount = this.getTokenCount(messages);
+        return tokenCount >= this.maxTokens * this.threshold;
+    }
+
+    /**
+     * Micro-compact: remove verbose tool results from messages older than N turns.
+     * Keeps the tool call reference but truncates result content.
+     * @param {Array} messages
+     * @param {number} recentTurns - number of recent user/assistant pairs to preserve
+     * @returns {Array}
+     */
+    microCompact(messages, recentTurns = STALE_TOOL_RESULT_TURNS) {
+        // Count turns (each user message is roughly one turn)
+        let turnCount = 0;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].role === 'user') turnCount++;
+        }
+
+        if (turnCount <= recentTurns) return messages;
+
+        // Mark the boundary: keep last recentTurns user messages intact
+        let usersSeen = 0;
+        let boundary = messages.length;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].role === 'user') {
+                usersSeen++;
+                if (usersSeen >= recentTurns) {
+                    boundary = i;
+                    break;
+                }
+            }
+        }
+
+        // Truncate tool results before the boundary
+        const result = messages.map((msg, idx) => {
+            if (idx >= boundary) return msg;
+            if (!Array.isArray(msg.content)) return msg;
+
+            const newContent = msg.content.map(block => {
+                if (block.type === 'tool_result' && typeof block.content === 'string' && block.content.length > 200) {
+                    return {
+                        ...block,
+                        content: block.content.slice(0, 100) + '...[truncated]',
+                    };
+                }
+                return block;
+            });
+
+            return { ...msg, content: newContent };
+        });
+
+        return result;
+    }
+
+    /**
+     * Compact messages by summarizing older history.
+     * Keeps the most recent N messages intact and replaces older ones
+     * with a summary message.
+     *
+     * @param {Array} messages - current conversation messages
+     * @param {number} keepRecent - number of recent messages to preserve (default 6 = ~3 turns)
+     * @returns {Array} compacted message array
+     */
+    compact(messages, keepRecent = 6) {
+        if (messages.length <= keepRecent) return messages;
+
+        this.lastPreCompactTokens = this.getTokenCount(messages);
+        this.compactionCount++;
+
+        // First try micro-compaction
+        let working = this.microCompact(messages);
+        if (!this.shouldCompact(working)) {
+            this.lastPostCompactTokens = this.getTokenCount(working);
+            return working;
+        }
+
+        // Full compaction
+        const oldMessages = messages.slice(0, -keepRecent);
+        const recentMessages = messages.slice(-keepRecent);
+
+        // Build a summary of old messages
+        const summaryParts = [];
+        for (const msg of oldMessages) {
+            const role = msg.role;
+            let text = '';
+            if (typeof msg.content === 'string') {
+                text = msg.content.slice(0, 200);
+            } else if (Array.isArray(msg.content)) {
+                text = msg.content
+                    .map(b => {
+                        if (b.type === 'text') return b.text?.slice(0, 100);
+                        if (b.type === 'tool_use') return `[tool:${b.name}]`;
+                        if (b.type === 'tool_result') return `[result:${String(b.content).slice(0, 80)}]`;
+                        return `[${b.type}]`;
+                    })
+                    .filter(Boolean)
+                    .join(' ');
+            }
+            if (text) summaryParts.push(`${role}: ${text}`);
+        }
+
+        const summary = {
+            role: 'user',
+            content: `[Context compacted — summary of ${oldMessages.length} earlier messages]\n` +
+                summaryParts.join('\n').slice(0, 2000),
+        };
+
+        const compacted = [summary, ...recentMessages];
+        this.lastPostCompactTokens = this.getTokenCount(compacted);
+        return compacted;
+    }
+
+    /**
+     * Add a message and auto-compact if needed.
+     * @param {Array} messages - mutable message array
+     * @param {object} msg - new message to add
+     * @returns {Array} possibly compacted array with new message
+     */
+    addMessage(messages, msg) {
+        messages.push(msg);
+        if (this.shouldCompact(messages)) {
+            return this.compact(messages);
+        }
+        return messages;
+    }
+
+    /**
+     * Get compaction statistics.
+     * @returns {object}
+     */
+    getStats() {
+        return {
+            compactionCount: this.compactionCount,
+            lastPreCompactTokens: this.lastPreCompactTokens,
+            lastPostCompactTokens: this.lastPostCompactTokens,
+        };
+    }
+}

package/src/core/providers.mjs

@@ -0,0 +1,219 @@
+/**
+ * Multi-Provider — unified provider config and request/response transforms.
+ *
+ * Supports: Anthropic, OpenAI, Google, Bedrock (stub), Vertex (stub).
+ * Each provider defines endpoint, auth headers, and optional transforms.
+ */
+
+const PROVIDERS = {
+    anthropic: {
+        name: 'Anthropic',
+        endpoint: 'https://api.anthropic.com/v1/messages',
+        envKey: 'ANTHROPIC_API_KEY',
+        authHeader(key) {
+            return {
+                'x-api-key': key,
+                'anthropic-version': '2023-06-01',
+                'Content-Type': 'application/json',
+            };
+        },
+        models: ['claude-sonnet-4-6', 'claude-haiku-4-5', 'claude-opus-4-6'],
+    },
+
+    openai: {
+        name: 'OpenAI',
+        endpoint: 'https://api.openai.com/v1/chat/completions',
+        envKey: 'OPENAI_API_KEY',
+        authHeader(key) {
+            return {
+                'Authorization': `Bearer ${key}`,
+                'Content-Type': 'application/json',
+            };
+        },
+        models: ['gpt-4o', 'gpt-4o-mini', 'o1-preview', 'o1-mini', 'o3-mini'],
+        transformRequest(body) {
+            const messages = [];
+            if (body.system) {
+                messages.push({ role: 'system', content: body.system });
+            }
+            for (const msg of body.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',
+                                tool_call_id: block.tool_use_id,
+                                content: block.content,
+                            });
+                        }
+                    }
+                }
+            }
+
+            const tools = (body.tools || []).map(t => ({
+                type: 'function',
+                function: { name: t.name, description: t.description, parameters: t.input_schema },
+            }));
+
+            return {
+                model: body.model,
+                messages,
+                ...(tools.length > 0 && { tools }),
+                ...(body.max_tokens && { max_tokens: body.max_tokens }),
+                ...(body.stream && { stream: true }),
+            };
+        },
+        transformResponse(data) {
+            const choice = data.choices?.[0];
+            if (!choice) throw new Error('No choices in OpenAI response');
+
+            const content = [];
+            if (choice.message?.content) {
+                content.push({ type: 'text', text: choice.message.content });
+            }
+            if (choice.message?.tool_calls) {
+                for (const tc of choice.message.tool_calls) {
+                    content.push({
+                        type: 'tool_use',
+                        id: tc.id,
+                        name: tc.function.name,
+                        input: JSON.parse(tc.function.arguments || '{}'),
+                    });
+                }
+            }
+
+            return {
+                content,
+                stop_reason: choice.finish_reason === 'stop' ? 'end_turn' : choice.finish_reason,
+                usage: {
+                    input_tokens: data.usage?.prompt_tokens || 0,
+                    output_tokens: data.usage?.completion_tokens || 0,
+                },
+            };
+        },
+    },
+
+    google: {
+        name: 'Google',
+        endpoint: 'https://generativelanguage.googleapis.com/v1beta/models',
+        envKey: 'GOOGLE_API_KEY',
+        altEnvKey: 'GEMINI_API_KEY',
+        authHeader(key) {
+            return { 'Content-Type': 'application/json' };
+        },
+        models: ['gemini-2.0-flash', 'gemini-2.0-pro', 'gemini-1.5-flash'],
+        transformRequest(body) {
+            const contents = [];
+            for (const msg of body.messages || []) {
+                const role = msg.role === 'assistant' ? 'model' : 'user';
+                if (typeof msg.content === 'string') {
+                    contents.push({ role, parts: [{ text: msg.content }] });
+                }
+            }
+
+            return {
+                contents,
+                ...(body.system && {
+                    systemInstruction: { parts: [{ text: body.system }] },
+                }),
+            };
+        },
+        transformResponse(data) {
+            const candidate = data.candidates?.[0];
+            if (!candidate) throw new Error('No candidates in Google response');
+
+            const content = [];
+            for (const part of candidate.content?.parts || []) {
+                if (part.text) content.push({ type: 'text', text: part.text });
+            }
+
+            return {
+                content,
+                stop_reason: 'end_turn',
+                usage: {
+                    input_tokens: data.usageMetadata?.promptTokenCount || 0,
+                    output_tokens: data.usageMetadata?.candidatesTokenCount || 0,
+                },
+            };
+        },
+    },
+
+    bedrock: {
+        name: 'AWS Bedrock',
+        endpoint: null, // Dynamic based on region
+        envKey: 'AWS_ACCESS_KEY_ID',
+        models: ['anthropic.claude-3-sonnet', 'anthropic.claude-3-haiku'],
+        authHeader() {
+            // AWS SigV4 signing would go here
+            return { 'Content-Type': 'application/json' };
+        },
+        getEndpoint(model, region = 'us-east-1') {
+            return `https://bedrock-runtime.${region}.amazonaws.com/model/${model}/invoke`;
+        },
+    },
+
+    vertex: {
+        name: 'Google Vertex AI',
+        endpoint: null, // Dynamic based on project/region
+        envKey: 'GOOGLE_APPLICATION_CREDENTIALS',
+        models: ['claude-sonnet-4-6@anthropic'],
+        authHeader() {
+            // GCP bearer token would go here
+            return { 'Content-Type': 'application/json' };
+        },
+        getEndpoint(model, project, region = 'us-central1') {
+            return `https://${region}-aiplatform.googleapis.com/v1/projects/${project}/locations/${region}/publishers/anthropic/models/${model}:rawPredict`;
+        },
+    },
+};
+
+/**
+ * Get the provider configuration for a given model.
+ * @param {string} model - model name
+ * @returns {object} provider config
+ */
+export function getProvider(model) {
+    if (model.startsWith('claude') || model.startsWith('anthropic')) return PROVIDERS.anthropic;
+    if (model.startsWith('gpt') || model.startsWith('o1') || model.startsWith('o3')) return PROVIDERS.openai;
+    if (model.startsWith('gemini')) return PROVIDERS.google;
+    return PROVIDERS.anthropic; // default
+}
+
+/**
+ * Get a provider by name.
+ * @param {string} name
+ * @returns {object|undefined}
+ */
+export function getProviderByName(name) {
+    return PROVIDERS[name];
+}
+
+/**
+ * List all supported providers.
+ * @returns {Array<{ name: string, envKey: string, models: string[] }>}
+ */
+export function listProviders() {
+    return Object.entries(PROVIDERS).map(([key, p]) => ({
+        id: key,
+        name: p.name,
+        envKey: p.envKey,
+        models: p.models || [],
+        hasEndpoint: !!p.endpoint,
+    }));
+}
+
+/**
+ * Check which providers have API keys configured.
+ * @returns {Array<{ id: string, name: string, configured: boolean }>}
+ */
+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])),
+    }));
+}
+
+export { PROVIDERS };

package/src/core/rate-limiter.mjs

@@ -0,0 +1,119 @@
+/**
+ * Rate Limiter — handle 429 and 529 API responses.
+ *
+ * Implements exponential backoff with jitter for rate-limited
+ * and overloaded API responses. Tracks retry state per-instance.
+ */
+
+export class RateLimiter {
+    /**
+     * @param {object} [options]
+     * @param {number} [options.maxRetries] - max number of retries (default: 5)
+     * @param {number} [options.baseDelay] - base delay in ms (default: 1000)
+     * @param {number} [options.maxDelay] - max delay in ms (default: 60000)
+     */
+    constructor(options = {}) {
+        this.maxRetries = options.maxRetries ?? 5;
+        this.baseDelay = options.baseDelay ?? 1000;
+        this.maxDelay = options.maxDelay ?? 60000;
+        this.retryAfter = 0;
+        this.retryCount = 0;
+        this.lastRetryAt = null;
+    }
+
+    /**
+     * Handle an API response and determine whether to retry.
+     * @param {{ status: number, headers: { get: (name: string) => string|null } }} response
+     * @returns {Promise<'ok'|'retry'|'fail'>}
+     */
+    async handleResponse(response) {
+        if (response.status === 429) {
+            // Rate limited
+            if (this.retryCount >= this.maxRetries) return 'fail';
+
+            const retryAfter = parseInt(response.headers?.get?.('retry-after') || '10', 10);
+            const delayMs = Math.min(retryAfter * 1000, this.maxDelay);
+            this.retryAfter = Date.now() + delayMs;
+            this.retryCount++;
+            this.lastRetryAt = new Date().toISOString();
+
+            await this.wait(delayMs);
+            return 'retry';
+        }
+
+        if (response.status === 529) {
+            // API overloaded
+            if (this.retryCount >= this.maxRetries) return 'fail';
+
+            const delay = this.calculateBackoff();
+            this.retryAfter = Date.now() + delay;
+            this.retryCount++;
+            this.lastRetryAt = new Date().toISOString();
+
+            await this.wait(delay);
+            return 'retry';
+        }
+
+        // Success — reset retry count
+        this.retryCount = 0;
+        return 'ok';
+    }
+
+    /**
+     * Calculate exponential backoff with jitter.
+     * @returns {number} delay in milliseconds
+     */
+    calculateBackoff() {
+        const exponential = this.baseDelay * Math.pow(2, this.retryCount);
+        const jitter = Math.random() * this.baseDelay;
+        return Math.min(exponential + jitter, this.maxDelay);
+    }
+
+    /**
+     * Check if we should wait before making a request.
+     * @returns {boolean}
+     */
+    shouldWait() {
+        return Date.now() < this.retryAfter;
+    }
+
+    /**
+     * Get remaining wait time in ms.
+     * @returns {number}
+     */
+    remainingWait() {
+        return Math.max(0, this.retryAfter - Date.now());
+    }
+
+    /**
+     * Reset all retry state.
+     */
+    reset() {
+        this.retryAfter = 0;
+        this.retryCount = 0;
+        this.lastRetryAt = null;
+    }
+
+    /**
+     * Get current limiter status.
+     */
+    status() {
+        return {
+            retryCount: this.retryCount,
+            maxRetries: this.maxRetries,
+            retryAfter: this.retryAfter,
+            lastRetryAt: this.lastRetryAt,
+            isWaiting: this.shouldWait(),
+            remainingMs: this.remainingWait(),
+        };
+    }
+
+    /**
+     * Wait for the specified duration.
+     * @param {number} ms
+     * @returns {Promise<void>}
+     */
+    wait(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}

package/src/core/scheduler.mjs

@@ -0,0 +1,173 @@
+/**
+ * Scheduler — cron-based task scheduling.
+ *
+ * Stores scheduled tasks in ~/.claude/scheduled_tasks.json.
+ * Tasks have a cron expression, prompt, and optional environment.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+
+export class Scheduler {
+    /**
+     * @param {string} [tasksFile] - path to scheduled tasks JSON
+     */
+    constructor(tasksFile) {
+        this.tasksFile = tasksFile ||
+            path.join(os.homedir(), '.claude', 'scheduled_tasks.json');
+        this.timers = new Map();
+    }
+
+    /**
+     * Create a new scheduled task.
+     * @param {string} cron - cron expression or interval shorthand (e.g., "5m", "1h")
+     * @param {string} prompt - prompt to execute
+     * @param {object} [options]
+     * @param {string} [options.name] - human-readable name
+     * @param {string} [options.model] - model to use
+     * @param {boolean} [options.enabled] - whether task is enabled (default: true)
+     * @returns {object} created task
+     */
+    async create(cron, prompt, options = {}) {
+        const tasks = this._loadTasks();
+        const task = {
+            id: `task_${crypto.randomBytes(4).toString('hex')}`,
+            name: options.name || `Task ${tasks.length + 1}`,
+            cron,
+            prompt,
+            model: options.model || null,
+            enabled: options.enabled !== false,
+            createdAt: new Date().toISOString(),
+            lastRun: null,
+            runCount: 0,
+            intervalMs: parseCronInterval(cron),
+        };
+
+        tasks.push(task);
+        this._saveTasks(tasks);
+        return task;
+    }
+
+    /**
+     * Delete a scheduled task by ID.
+     * @param {string} taskId
+     * @returns {boolean} true if deleted
+     */
+    async delete(taskId) {
+        const tasks = this._loadTasks();
+        const idx = tasks.findIndex(t => t.id === taskId);
+        if (idx === -1) return false;
+
+        tasks.splice(idx, 1);
+        this._saveTasks(tasks);
+
+        // Clear timer if running
+        if (this.timers.has(taskId)) {
+            clearInterval(this.timers.get(taskId));
+            this.timers.delete(taskId);
+        }
+
+        return true;
+    }
+
+    /**
+     * List all scheduled tasks.
+     * @returns {Array<object>}
+     */
+    async list() {
+        return this._loadTasks();
+    }
+
+    /**
+     * Check and return tasks that are due to run.
+     * @returns {Array<object>} tasks that are due
+     */
+    async runDue() {
+        const tasks = this._loadTasks();
+        const due = [];
+        const now = Date.now();
+
+        for (const task of tasks) {
+            if (!task.enabled) continue;
+            if (!task.intervalMs) continue;
+
+            const lastRun = task.lastRun ? new Date(task.lastRun).getTime() : 0;
+            if (now - lastRun >= task.intervalMs) {
+                task.lastRun = new Date().toISOString();
+                task.runCount = (task.runCount || 0) + 1;
+                due.push(task);
+            }
+        }
+
+        if (due.length > 0) {
+            this._saveTasks(tasks);
+        }
+
+        return due;
+    }
+
+    /**
+     * Enable or disable a task.
+     * @param {string} taskId
+     * @param {boolean} enabled
+     * @returns {boolean}
+     */
+    async setEnabled(taskId, enabled) {
+        const tasks = this._loadTasks();
+        const task = tasks.find(t => t.id === taskId);
+        if (!task) return false;
+
+        task.enabled = enabled;
+        this._saveTasks(tasks);
+        return true;
+    }
+
+    /**
+     * Load tasks from disk.
+     * @returns {Array<object>}
+     */
+    _loadTasks() {
+        try {
+            const raw = fs.readFileSync(this.tasksFile, 'utf-8');
+            return JSON.parse(raw);
+        } catch {
+            return [];
+        }
+    }
+
+    /**
+     * Save tasks to disk.
+     * @param {Array<object>} tasks
+     */
+    _saveTasks(tasks) {
+        try {
+            const dir = path.dirname(this.tasksFile);
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(this.tasksFile, JSON.stringify(tasks, null, 2));
+        } catch {
+            // Best effort
+        }
+    }
+}
+
+/**
+ * Parse a cron expression or interval shorthand into milliseconds.
+ * @param {string} cron
+ * @returns {number}
+ */
+export function parseCronInterval(cron) {
+    const match = cron.match(/^(\d+)(s|m|h|d)$/);
+    if (match) {
+        const value = parseInt(match[1], 10);
+        const units = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+        return value * (units[match[2]] || 60000);
+    }
+
+    const num = parseInt(cron, 10);
+    if (!isNaN(num)) return num * 60000;
+
+    // Full cron expression — default to 5 minutes
+    return 300000;
+}