orquesta-cli 0.2.47 → 0.2.49

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/core/usage-tracker.js

@@ -198,13 +198,13 @@ class UsageTrackerClass {
             tokenStr = `${(tokens / 1000000).toFixed(2)}M`;
         }
         const activity = currentActivity || 'Processing';
-        return `✶ ${activity}… (esc to interrupt · ${timeStr} · ↑ ${tokenStr} tokens)`;
+        return `🎵 ${activity}… (esc to interrupt · ${timeStr} · ↑ ${tokenStr} tokens)`;
     }
     formatUsageDisplay() {
         logger.enter('UsageTracker.formatUsageDisplay');
         const summary = this.getSummary();
         const lines = [];
-        lines.push('📊 Usage Statistics');
+        lines.push('🎼 Usage Statistics');
         lines.push('');
         lines.push('📅 Today');
         if (summary.today) {

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();
@@ -139,8 +146,8 @@ export class PlanExecutor {
                 callbacks.setTodos(currentTodos);
                 emitPlanCreated(currentTodos.map(t => t.title));
                 const planMessage = planResult.docsSearchNeeded
-                    ? `📋 Created ${currentTodos.length} tasks (including docs search). Starting execution...`
-                    : `📋 Created ${currentTodos.length} tasks. Starting execution...`;
+                    ? `🎼 Created ${currentTodos.length} tasks (including docs search). Starting execution...`
+                    : `🎼 Created ${currentTodos.length} tasks. Starting execution...`;
                 const lastMsgForPlan = currentMessages[currentMessages.length - 1];
                 const needsUserMessageForPlan = !(lastMsgForPlan?.role === 'user' && lastMsgForPlan?.content === userMessage);
                 currentMessages = needsUserMessageForPlan
@@ -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/orchestration/utils.js

@@ -47,7 +47,7 @@ export function buildTodoContext(todos) {
     }).join('\n');
     return `
 ---
-## 📋 Current TODO List (${completedCount}/${todos.length} completed)
+## 🎼 Current TODO List (${completedCount}/${todos.length} completed)
 
 ${todoList}
 

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/dist/ui/components/ActivityIndicator.js

@@ -3,16 +3,16 @@ import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { logger } from '../../utils/logger.js';
 const ACTIVITY_INFO = {
-    thinking: { icon: '💭', label: 'Thinking', color: 'magenta', spinnerType: 'dots' },
-    planning: { icon: '💭', label: 'Thinking', color: 'blue', spinnerType: 'dots' },
-    executing: { icon: '⚡', label: 'Executing', color: 'green', spinnerType: 'line' },
-    docs_search: { icon: '📚', label: 'Searching docs', color: 'yellow', spinnerType: 'dots' },
-    file_read: { icon: '📖', label: 'Reading file', color: 'cyan', spinnerType: 'pipe' },
-    file_write: { icon: '✏️', label: 'Writing file', color: 'green', spinnerType: 'pipe' },
-    file_search: { icon: '🔍', label: 'Searching files', color: 'yellow', spinnerType: 'dots' },
-    tool_call: { icon: '🔧', label: 'Tool call', color: 'yellow', spinnerType: 'star' },
-    validating: { icon: '✓', label: 'Validating', color: 'cyan', spinnerType: 'dots' },
-    waiting: { icon: '⏳', label: 'Waiting', color: 'gray', spinnerType: 'dots' },
+    thinking: { icon: '🎵', label: 'Thinking', color: 'magenta', spinnerType: 'dots' },
+    planning: { icon: '🎼', label: 'Composing', color: 'blue', spinnerType: 'dots' },
+    executing: { icon: '🥁', label: 'Executing', color: 'green', spinnerType: 'line' },
+    docs_search: { icon: '🎷', label: 'Searching docs', color: 'yellow', spinnerType: 'dots' },
+    file_read: { icon: '🎸', label: 'Reading file', color: 'cyan', spinnerType: 'pipe' },
+    file_write: { icon: '🎹', label: 'Writing file', color: 'green', spinnerType: 'pipe' },
+    file_search: { icon: '🎺', label: 'Searching files', color: 'yellow', spinnerType: 'dots' },
+    tool_call: { icon: '🪕', label: 'Tool call', color: 'yellow', spinnerType: 'star' },
+    validating: { icon: '🎻', label: 'Validating', color: 'cyan', spinnerType: 'dots' },
+    waiting: { icon: '🪘', label: 'Waiting', color: 'gray', spinnerType: 'dots' },
 };
 function formatTokens(count) {
     if (count < 1000)

package/dist/ui/components/PlanExecuteApp.js

@@ -1233,21 +1233,21 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
                         return '🌐';
                     switch (toolName) {
                         case 'read_file':
-                            return '📖';
+                            return '🎸';
                         case 'create_file':
-                            return '📝';
+                            return '🎹';
                         case 'edit_file':
-                            return '✏️';
+                            return '🎻';
                         case 'list_files':
-                            return '📂';
+                            return '🎼';
                         case 'find_files':
-                            return '🔍';
+                            return '🎷';
                         case 'tell_to_user':
-                            return '💬';
+                            return '🎺';
                         case 'bash':
-                            return '⚡';
+                            return '🥁';
                         default:
-                            return '🔧';
+                            return '🪕';
                     }
                 };
                 const getToolParams = (toolName, args) => {

package/dist/ui/components/StatusBar.js

@@ -30,7 +30,7 @@ const Clock = () => {
 };
 const AnimatedStar = () => {
     const [phase, setPhase] = useState(0);
-    const stars = ['✶', '✷', '✸', '✷'];
+    const stars = ['🎵', '🎶', '♪', '♫'];
     const colors = ['magentaBright', 'magenta', 'gray', 'magenta'];
     useEffect(() => {
         const interval = setInterval(() => {

package/dist/ui/components/ThinkingIndicator.js

@@ -3,13 +3,13 @@ import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { logger } from '../../utils/logger.js';
 const PHASE_INFO = {
-    analyzing: { icon: '🔍', label: 'Analyzing', color: 'yellow' },
-    planning: { icon: '💭', label: 'Thinking', color: 'blue' },
-    generating: { icon: '✨', label: 'Generating', color: 'magenta' },
-    executing: { icon: '⚡', label: 'Executing', color: 'green' },
-    validating: { icon: '✓', label: 'Validating', color: 'cyan' },
-    tool_calling: { icon: '🔧', label: 'Tool Call', color: 'yellow' },
-    waiting: { icon: '⏳', label: 'Waiting', color: 'gray' },
+    analyzing: { icon: '🎷', label: 'Analyzing', color: 'yellow' },
+    planning: { icon: '🎼', label: 'Composing', color: 'blue' },
+    generating: { icon: '🎹', label: 'Generating', color: 'magenta' },
+    executing: { icon: '🥁', label: 'Executing', color: 'green' },
+    validating: { icon: '🎻', label: 'Validating', color: 'cyan' },
+    tool_calling: { icon: '🪕', label: 'Tool Call', color: 'yellow' },
+    waiting: { icon: '🪘', label: 'Waiting', color: 'gray' },
 };
 export const ThinkingIndicator = ({ phase, startTime, currentStep, totalSteps, completedSteps, }) => {
     const [elapsedSeconds, setElapsedSeconds] = useState(0);

package/dist/ui/components/views/ChatView.js

@@ -66,22 +66,22 @@ export const ChatView = ({ messages, currentResponse, maxDisplayMessages = 10, s
             content.includes('`');
     };
     const TOOL_ICONS = {
-        'read_file': '📖',
-        'Read': '📖',
-        'create_file': '📝',
-        'Create': '📝',
-        'edit_file': '✏️',
-        'Edit': '✏️',
-        'search_files': '🔍',
-        'Search': '🔍',
-        'Grep': '🔍',
-        'grep_search': '🔍',
-        'list_files': '📁',
-        'list_directory': '📁',
-        'Glob': '📁',
-        'find_files': '🔎',
-        'execute_command': '⚡',
-        'Bash': '⚡',
+        'read_file': '🎸',
+        'Read': '🎸',
+        'create_file': '🎹',
+        'Create': '🎹',
+        'edit_file': '🎻',
+        'Edit': '🎻',
+        'search_files': '🎷',
+        'Search': '🎷',
+        'Grep': '🎷',
+        'grep_search': '🎷',
+        'list_files': '🎼',
+        'list_directory': '🎼',
+        'Glob': '🎼',
+        'find_files': '🎷',
+        'execute_command': '🥁',
+        'Bash': '🥁',
     };
     const normalizeToolName = (name) => {
         const nameMap = {

package/package.json

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