orquesta-cli 0.2.47 → 0.2.48

package/dist/core/compact/context-tracker.js

@@ -1,7 +1,7 @@
 import { logger } from '../../utils/logger.js';
 class ContextTrackerClass {
     lastPromptTokens = 0;
-    autoCompactThreshold = 70;
+    autoCompactThreshold = 50;
     autoCompactTriggered = false;
     recentFiles = new Set();
     maxRecentFiles = 20;

package/dist/core/file-cache.d.ts

@@ -0,0 +1,5 @@
+export declare function getCachedFile(path: string): string | null;
+export declare function setCachedFile(path: string, content: string): void;
+export declare function invalidateCache(path: string): void;
+export declare function clearFileCache(): void;
+//# sourceMappingURL=file-cache.d.ts.map

package/dist/core/file-cache.js

@@ -0,0 +1,27 @@
+import * as fs from 'fs';
+const cache = new Map();
+export function getCachedFile(path) {
+    const entry = cache.get(path);
+    if (!entry)
+        return null;
+    try {
+        const stat = fs.statSync(path);
+        if (stat.mtimeMs === entry.mtime)
+            return entry.content;
+        cache.delete(path);
+    }
+    catch {
+        cache.delete(path);
+    }
+    return null;
+}
+export function setCachedFile(path, content) {
+    try {
+        const stat = fs.statSync(path);
+        cache.set(path, { content, mtime: stat.mtimeMs });
+    }
+    catch { }
+}
+export function invalidateCache(path) { cache.delete(path); }
+export function clearFileCache() { cache.clear(); }
+//# sourceMappingURL=file-cache.js.map

package/dist/core/llm/llm-client.d.ts

@@ -1,4 +1,5 @@
 import { Message, LLMRequestOptions } from '../../types/index.js';
+export declare function fetchWithRetry(url: string, options: RequestInit, maxRetries?: number): Promise<Response>;
 export interface LLMResponse {
     id: string;
     object: string;

package/dist/core/llm/llm-client.js

@@ -100,6 +100,20 @@ function captureBatutaHeaders(headers) {
         setLastBatutaRoute({ tier, routedTo, routedFrom });
     }
 }
+export async function fetchWithRetry(url, options, maxRetries = 3) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        const res = await fetch(url, options);
+        if (res.ok || attempt === maxRetries)
+            return res;
+        if (res.status === 429 || res.status >= 500) {
+            const delay = Math.min(1000 * 2 ** attempt, 30000);
+            await new Promise(r => setTimeout(r, delay));
+            continue;
+        }
+        return res;
+    }
+    throw new Error('Unreachable');
+}
 export class LLMClient {
     axiosInstance;
     baseUrl;
@@ -138,29 +152,33 @@ export class LLMClient {
         });
     }
     preprocessMessages(messages, modelId) {
+        const isGptOss = /^gpt-oss-(120b|20b)$/i.test(modelId);
         return messages.map((msg) => {
-            let processedMsg = { ...msg };
-            const multimodal = processedMsg.multimodal;
+            const multimodal = msg.multimodal;
             if (multimodal && Array.isArray(multimodal)) {
+                const processedMsg = { ...msg };
                 processedMsg.content = multimodal;
                 delete processedMsg.multimodal;
                 return processedMsg;
             }
             if (msg.role !== 'assistant') {
-                return processedMsg;
+                return msg;
+            }
+            const msgAny = msg;
+            const needsReasoningFix = msgAny.reasoning_content && (!msg.content || msg.content.trim() === '');
+            const needsHarmonyFix = isGptOss && msg.tool_calls && msg.tool_calls.length > 0 && (!msg.content || msg.content.trim() === '');
+            const needsNullFix = msg.content === undefined || msg.content === null;
+            if (!needsReasoningFix && !needsHarmonyFix && !needsNullFix) {
+                return msg;
             }
-            const msgAny = processedMsg;
-            if (msgAny.reasoning_content && (!msg.content || msg.content.trim() === '')) {
+            const processedMsg = { ...msg };
+            if (needsReasoningFix) {
                 processedMsg.content = msgAny.reasoning_content;
                 delete processedMsg.reasoning_content;
             }
-            if (/^gpt-oss-(120b|20b)$/i.test(modelId)) {
-                if (msg.tool_calls && msg.tool_calls.length > 0) {
-                    if (!processedMsg.content || processedMsg.content.trim() === '') {
-                        const toolNames = msg.tool_calls.map(tc => tc.function.name).join(', ');
-                        processedMsg.content = msgAny.reasoning || `Calling tools: ${toolNames}`;
-                    }
-                }
+            if (needsHarmonyFix) {
+                const toolNames = msg.tool_calls.map(tc => tc.function.name).join(', ');
+                processedMsg.content = msgAny.reasoning || `Calling tools: ${toolNames}`;
             }
             if (processedMsg.content === undefined || processedMsg.content === null) {
                 processedMsg.content = '';
@@ -185,12 +203,14 @@ export class LLMClient {
             const processedMessages = options.messages ?
                 this.preprocessMessages(options.messages, modelId) : [];
             logger.vars({ name: 'modelId', value: modelId }, { name: 'originalMessages', value: options.messages?.length || 0 }, { name: 'processedMessages', value: processedMessages.length }, { name: 'temperature', value: options.temperature ?? 0 });
+            const isClaudeModel = /claude|sonnet|opus|haiku/i.test(modelId);
             const requestBody = {
                 model: modelId,
                 messages: processedMessages,
                 temperature: options.temperature ?? 0,
                 max_tokens: options.max_tokens,
                 stream: false,
+                ...(isClaudeModel && { thinking: { type: 'enabled', budget_tokens: 10000 } }),
                 ...(options.tools && {
                     tools: options.tools,
                     parallel_tool_calls: false,
@@ -451,12 +471,14 @@ export class LLMClient {
             const modelId = options.model || this.model;
             const processedMessages = options.messages ?
                 this.preprocessMessages(options.messages, modelId) : [];
+            const isClaudeModel = /claude|sonnet|opus|haiku/i.test(modelId);
             const requestBody = {
                 model: modelId,
                 messages: processedMessages,
                 temperature: options.temperature ?? 0,
                 max_tokens: options.max_tokens,
                 stream: true,
+                ...(isClaudeModel && { thinking: { type: 'enabled', budget_tokens: 10000 } }),
                 ...(options.tools && {
                     tools: options.tools,
                     ...(options.tool_choice && { tool_choice: options.tool_choice }),
@@ -597,6 +619,7 @@ export class LLMClient {
         let contextLengthRecoveryAttempted = false;
         let finalResponseFailures = 0;
         const MAX_FINAL_RESPONSE_FAILURES = 3;
+        const { executeFileTool, requestToolApproval, emitAssistantResponse } = await import('../../tools/llm/simple/file-tools.js');
         const recentToolSignatures = [];
         const recentNormalizedSignatures = [];
         const LOOP_WINDOW = 5;
@@ -736,7 +759,6 @@ export class LLMClient {
                         });
                         continue;
                     }
-                    const { executeFileTool, requestToolApproval } = await import('../../tools/llm/simple/file-tools.js');
                     const approvalResult = await requestToolApproval(toolName, toolArgs);
                     if (approvalResult && typeof approvalResult === 'object' && approvalResult.reject) {
                         logger.flow(`Tool rejected by user: ${toolName}`);
@@ -791,7 +813,6 @@ export class LLMClient {
                                 if (finalResponseFailures >= MAX_FINAL_RESPONSE_FAILURES) {
                                     logger.warn('Max final_response failures exceeded - forcing completion');
                                     const fallbackMessage = toolArgs['message'] || 'Task completed with incomplete TODOs.';
-                                    const { emitAssistantResponse } = await import('../../tools/llm/simple/file-tools.js');
                                     emitAssistantResponse(fallbackMessage);
                                     return {
                                         message: { role: 'assistant', content: fallbackMessage },

package/dist/orchestration/plan-executor.d.ts

@@ -5,7 +5,9 @@ import type { StateCallbacks } from './types.js';
 export declare function setAppendedSystemPrompt(text: string): void;
 export declare class PlanExecutor {
     private currentLLMClient;
+    private cachedSystemPrompt;
     constructor();
+    private getSystemPrompt;
     executePlanMode(userMessage: string, llmClient: LLMClient, messages: Message[], isInterruptedRef: {
         current: boolean;
     }, callbacks: StateCallbacks): Promise<void>;

package/dist/orchestration/plan-executor.js

@@ -40,8 +40,15 @@ function buildSystemPrompt() {
 }
 export class PlanExecutor {
     currentLLMClient = null;
+    cachedSystemPrompt = null;
     constructor() {
     }
+    getSystemPrompt() {
+        if (!this.cachedSystemPrompt) {
+            this.cachedSystemPrompt = buildSystemPrompt();
+        }
+        return this.cachedSystemPrompt;
+    }
     async executePlanMode(userMessage, llmClient, messages, isInterruptedRef, callbacks) {
         const planningStartTime = Date.now();
         const streamLogger = getStreamLogger();
@@ -163,7 +170,7 @@ export class PlanExecutor {
             const hasSystemMessage = currentMessages.some(m => m.role === 'system');
             if (!hasSystemMessage) {
                 currentMessages = [
-                    { role: 'system', content: buildSystemPrompt() },
+                    { role: 'system', content: this.getSystemPrompt() },
                     ...currentMessages
                 ];
             }
@@ -191,7 +198,7 @@ export class PlanExecutor {
             });
             if (useParallel && sessionId) {
                 logger.flow('Dispatching parallel orchestrator', { todoCount: currentTodos.length });
-                const baseSystem = currentMessages.find(m => m.role === 'system')?.content || buildSystemPrompt();
+                const baseSystem = currentMessages.find(m => m.role === 'system')?.content || this.getSystemPrompt();
                 const graphResult = await runParallelGraph({
                     llmClient,
                     todos: currentTodos,
@@ -285,6 +292,7 @@ export class PlanExecutor {
             clearFinalResponseCallbacks();
             clearDocsSearchLLMClientGetter();
             this.currentLLMClient = null;
+            this.cachedSystemPrompt = null;
         }
     }
     async resumeTodoExecution(userMessage, llmClient, messages, todos, isInterruptedRef, callbacks) {
@@ -311,7 +319,7 @@ export class PlanExecutor {
             const hasSystemMessage = currentMessages.some(m => m.role === 'system');
             if (!hasSystemMessage) {
                 currentMessages = [
-                    { role: 'system', content: buildSystemPrompt() },
+                    { role: 'system', content: this.getSystemPrompt() },
                     ...currentMessages
                 ];
             }
@@ -355,6 +363,7 @@ export class PlanExecutor {
             clearFinalResponseCallbacks();
             clearDocsSearchLLMClientGetter();
             this.currentLLMClient = null;
+            this.cachedSystemPrompt = null;
         }
     }
     async executeAutoMode(userMessage, llmClient, messages, _todos, isInterruptedRef, callbacks) {

package/dist/tools/llm/simple/file-tools.js

@@ -2,6 +2,7 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { logger } from '../../../utils/logger.js';
 import { shouldIgnore } from '../../../core/ignore-filter.js';
+import { getCachedFile, setCachedFile, invalidateCache } from '../../../core/file-cache.js';
 const EXCLUDED_DIRS = new Set([
     'node_modules',
     '.git',
@@ -71,7 +72,8 @@ async function _executeReadFile(args) {
                 error: `File too large to read (${(stats.size / 1024 / 1024).toFixed(2)}MB). Maximum: ${MAX_FILE_SIZE / 1024 / 1024}MB`,
             };
         }
-        const content = await fs.readFile(resolvedPath, 'utf-8');
+        const content = getCachedFile(resolvedPath) ?? await fs.readFile(resolvedPath, 'utf-8');
+        setCachedFile(resolvedPath, content);
         const allLines = content.split('\n');
         const totalLines = allLines.length;
         const startIdx = offset - 1;
@@ -192,6 +194,7 @@ async function _executeCreateFile(args) {
         const dir = path.dirname(resolvedPath);
         await fs.mkdir(dir, { recursive: true });
         await fs.writeFile(resolvedPath, content, 'utf-8');
+        invalidateCache(resolvedPath);
         const lines = content.split('\n').length;
         logger.toolSuccess('create_file', args, { file: displayPath, lines }, 0);
         return {
@@ -354,6 +357,7 @@ async function _executeEditFile(args) {
             };
         }
         await fs.writeFile(resolvedPath, newContent, 'utf-8');
+        invalidateCache(resolvedPath);
         const oldLinesArr = oldString.split('\n');
         const newLinesArr = newString.split('\n');
         const replacements = replaceAll ? occurrences : 1;

package/dist/tools/llm/simple/simple-tool-executor.js

@@ -106,6 +106,20 @@ export function emitReasoning(content, isStreaming = false) {
         reasoningCallback(content, isStreaming);
     }
 }
+function truncateToolResult(toolName, result) {
+    const totalChars = result.length;
+    if (toolName === 'read_file') {
+        const totalLines = result.split('\n').length;
+        return result.slice(0, 20000) + `\n\n[...truncated. File has ${totalLines} total lines. Use offset parameter to read more.]`;
+    }
+    if (toolName === 'bash') {
+        return result.slice(0, 10000) + `\n\n[...truncated middle. Total output: ${totalChars} chars]\n\n` + result.slice(-5000);
+    }
+    if (toolName === 'search_content' || toolName === 'find_files') {
+        return result.slice(0, 15000) + `\n\n[...truncated. Total output: ${totalChars} chars]`;
+    }
+    return result.slice(0, 20000) + `\n\n[...truncated. Total output: ${totalChars} chars]`;
+}
 export async function executeSimpleTool(toolName, args) {
     const startTime = Date.now();
     const logger = getStreamLogger();
@@ -141,6 +155,9 @@ export async function executeSimpleTool(toolName, args) {
             error: result.success ? undefined : result.error,
         });
     }
+    if (result.success && result.result && result.result.length > 30000) {
+        return { ...result, result: truncateToolResult(toolName, result.result) };
+    }
     return result;
 }
 export const executeFileTool = executeSimpleTool;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.2.47",
+  "version": "0.2.48",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",