orquesta-cli 0.2.44 → 0.2.46

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

@@ -108,6 +108,7 @@ export class LLMClient {
     modelName;
     currentAbortController = null;
     isInterrupted = false;
+    onStreamingContent = null;
     static DEFAULT_MAX_RETRIES = 3;
     constructor() {
         const endpoint = configManager.getCurrentEndpoint();
@@ -183,11 +184,11 @@ export class LLMClient {
             const modelId = options.model || this.model;
             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.7 });
+            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 requestBody = {
                 model: modelId,
                 messages: processedMessages,
-                temperature: options.temperature ?? 0.7,
+                temperature: options.temperature ?? 0,
                 max_tokens: options.max_tokens,
                 stream: false,
                 ...(options.tools && {
@@ -210,13 +211,112 @@ export class LLMClient {
             }
             logger.startTimer('llm-api-call');
             this.currentAbortController = new AbortController();
-            const response = await this.axiosInstance.post(url, requestBody, {
-                signal: this.currentAbortController.signal,
-                headers: buildPerRequestHeaders(),
-            });
-            this.currentAbortController = null;
+            let response;
+            if (this.onStreamingContent) {
+                const streamRequestBody = { ...requestBody, stream: true };
+                const streamResp = await this.axiosInstance.post(url, streamRequestBody, {
+                    responseType: 'stream',
+                    signal: this.currentAbortController.signal,
+                    headers: buildPerRequestHeaders(),
+                });
+                captureBatutaHeaders(streamResp.headers);
+                const stream = streamResp.data;
+                let buffer = '';
+                let contentAccum = '';
+                let reasoningAccum = '';
+                let role = 'assistant';
+                let finishReason = null;
+                const toolCallsMap = new Map();
+                let responseId = '';
+                let responseModel = '';
+                for await (const chunk of stream) {
+                    if (this.isInterrupted) {
+                        throw new Error('INTERRUPTED');
+                    }
+                    buffer += chunk.toString();
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed || trimmed === 'data: [DONE]')
+                            continue;
+                        if (!trimmed.startsWith('data: '))
+                            continue;
+                        try {
+                            const data = JSON.parse(trimmed.slice(6));
+                            if (data.id)
+                                responseId = data.id;
+                            if (data.model)
+                                responseModel = data.model;
+                            const choice = data.choices?.[0];
+                            if (!choice)
+                                continue;
+                            if (choice.finish_reason)
+                                finishReason = choice.finish_reason;
+                            const delta = choice.delta;
+                            if (!delta)
+                                continue;
+                            if (delta.role)
+                                role = delta.role;
+                            if (delta.content) {
+                                contentAccum += delta.content;
+                                this.onStreamingContent(delta.content);
+                            }
+                            if (delta.reasoning) {
+                                reasoningAccum += delta.reasoning;
+                            }
+                            if (delta.tool_calls) {
+                                for (const tc of delta.tool_calls) {
+                                    const idx = tc.index ?? 0;
+                                    if (!toolCallsMap.has(idx)) {
+                                        toolCallsMap.set(idx, { id: tc.id || '', type: 'function', function: { name: '', arguments: '' } });
+                                    }
+                                    const existing = toolCallsMap.get(idx);
+                                    if (tc.id)
+                                        existing.id = tc.id;
+                                    if (tc.function?.name)
+                                        existing.function.name += tc.function.name;
+                                    if (tc.function?.arguments)
+                                        existing.function.arguments += tc.function.arguments;
+                                }
+                            }
+                        }
+                        catch { }
+                    }
+                }
+                this.currentAbortController = null;
+                const toolCalls = Array.from(toolCallsMap.values())
+                    .filter(tc => tc.id && tc.function.name)
+                    .map(tc => ({ id: tc.id, type: 'function', function: { name: tc.function.name, arguments: tc.function.arguments } }));
+                const reassembledMessage = {
+                    role: role,
+                    content: contentAccum,
+                    ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+                    ...(reasoningAccum ? { reasoning: reasoningAccum } : {}),
+                };
+                response = {
+                    data: {
+                        id: responseId,
+                        object: 'chat.completion',
+                        created: Math.floor(Date.now() / 1000),
+                        model: responseModel || modelId,
+                        choices: [{ index: 0, message: reassembledMessage, finish_reason: finishReason }],
+                    },
+                    status: streamResp.status,
+                    statusText: streamResp.statusText,
+                    headers: streamResp.headers,
+                };
+            }
+            else {
+                const httpResp = await this.axiosInstance.post(url, requestBody, {
+                    signal: this.currentAbortController.signal,
+                    headers: buildPerRequestHeaders(),
+                });
+                this.currentAbortController = null;
+                response = { data: httpResp.data, status: httpResp.status, statusText: httpResp.statusText, headers: httpResp.headers };
+                captureBatutaHeaders(response.headers);
+            }
             const elapsed = logger.endTimer('llm-api-call');
-            captureBatutaHeaders(response.headers);
             logger.flow('API response received');
             if (!response.data.choices || !Array.isArray(response.data.choices)) {
                 logger.error('Invalid response structure - missing choices array', response.data);
@@ -354,7 +454,7 @@ export class LLMClient {
             const requestBody = {
                 model: modelId,
                 messages: processedMessages,
-                temperature: options.temperature ?? 0.7,
+                temperature: options.temperature ?? 0,
                 max_tokens: options.max_tokens,
                 stream: true,
                 ...(options.tools && {
@@ -495,9 +595,7 @@ export class LLMClient {
         const toolCallHistory = [];
         let iterations = 0;
         let contextLengthRecoveryAttempted = false;
-        let noToolCallRetries = 0;
         let finalResponseFailures = 0;
-        const MAX_NO_TOOL_CALL_RETRIES = 3;
         const MAX_FINAL_RESPONSE_FAILURES = 3;
         const recentToolSignatures = [];
         const recentNormalizedSignatures = [];
@@ -524,7 +622,7 @@ export class LLMClient {
                 response = await this.chatCompletion({
                     messages: workingMessages,
                     tools,
-                    tool_choice: 'required',
+                    tool_choice: 'auto',
                     ...(roleModel ? { model: roleModel } : {}),
                 });
             }
@@ -733,34 +831,14 @@ export class LLMClient {
                 continue;
             }
             else {
-                noToolCallRetries++;
-                logger.flow(`No tool call - enforcing tool usage (attempt ${noToolCallRetries}/${MAX_NO_TOOL_CALL_RETRIES})`);
-                if (noToolCallRetries > MAX_NO_TOOL_CALL_RETRIES) {
-                    logger.warn('Max no-tool-call retries exceeded - returning content as final response');
-                    const fallbackContent = assistantMessage.content || 'Task completed.';
-                    const { emitAssistantResponse } = await import('../../tools/llm/simple/file-tools.js');
-                    emitAssistantResponse(fallbackContent);
-                    return {
-                        message: { role: 'assistant', content: fallbackContent },
-                        toolCalls: toolCallHistory,
-                        allMessages: workingMessages,
-                    };
-                }
-                const hasMalformedToolCall = assistantMessage.content &&
-                    (/<tool_call>/i.test(assistantMessage.content) ||
-                        /<arg_key>/i.test(assistantMessage.content) ||
-                        /<arg_value>/i.test(assistantMessage.content) ||
-                        /<\/tool_call>/i.test(assistantMessage.content) ||
-                        /bash<arg_key>/i.test(assistantMessage.content));
-                const retryMessage = hasMalformedToolCall
-                    ? 'Your previous response contained a malformed tool call (XML tags in content). You MUST use the proper tool_calls API format. Use final_response tool to deliver your message to the user.'
-                    : 'You must use tools for all actions. Use final_response tool to deliver your final message to the user after completing all tasks.';
-                workingMessages.push({
-                    role: 'user',
-                    content: retryMessage,
-                });
-                logger.debug('Enforcing tool call - added retry message');
-                continue;
+                const finalContent = assistantMessage.content || 'Task completed.';
+                const { emitAssistantResponse } = await import('../../tools/llm/simple/file-tools.js');
+                emitAssistantResponse(finalContent);
+                return {
+                    message: { role: 'assistant', content: finalContent },
+                    toolCalls: toolCallHistory,
+                    allMessages: workingMessages,
+                };
             }
         }
     }

package/dist/core/memory.d.ts

@@ -0,0 +1,7 @@
+export declare function getUserMemory(): string;
+export declare function getMemoryPrompt(): string;
+export declare function addMemory(entry: string): void;
+export declare function removeMemory(index: number): boolean;
+export declare function clearMemory(): void;
+export declare function listMemory(): string[];
+//# sourceMappingURL=memory.d.ts.map

package/dist/core/memory.js

@@ -0,0 +1,55 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { LOCAL_HOME_DIR } from '../constants.js';
+const MEMORY_PATH = path.join(LOCAL_HOME_DIR, 'memory.md');
+let cache = null;
+export function getUserMemory() {
+    if (cache !== null)
+        return cache;
+    try {
+        cache = fs.readFileSync(MEMORY_PATH, 'utf-8').trim();
+    }
+    catch {
+        cache = '';
+    }
+    return cache;
+}
+export function getMemoryPrompt() {
+    const memory = getUserMemory();
+    if (!memory)
+        return '';
+    return `\n\n<user_memory>\nThe user has saved these persistent preferences and notes:\n${memory}\n</user_memory>\n`;
+}
+export function addMemory(entry) {
+    const current = getUserMemory();
+    const timestamp = new Date().toISOString().slice(0, 10);
+    const newContent = current ? `${current}\n- ${entry} (${timestamp})` : `- ${entry} (${timestamp})`;
+    fs.mkdirSync(path.dirname(MEMORY_PATH), { recursive: true });
+    fs.writeFileSync(MEMORY_PATH, newContent, 'utf-8');
+    cache = newContent;
+}
+export function removeMemory(index) {
+    const current = getUserMemory();
+    const lines = current.split('\n').filter(l => l.trim());
+    if (index < 1 || index > lines.length)
+        return false;
+    lines.splice(index - 1, 1);
+    const newContent = lines.join('\n');
+    fs.writeFileSync(MEMORY_PATH, newContent, 'utf-8');
+    cache = newContent;
+    return true;
+}
+export function clearMemory() {
+    try {
+        fs.unlinkSync(MEMORY_PATH);
+    }
+    catch { }
+    cache = '';
+}
+export function listMemory() {
+    const current = getUserMemory();
+    if (!current)
+        return [];
+    return current.split('\n').filter(l => l.trim());
+}
+//# sourceMappingURL=memory.js.map

package/dist/core/onboarding.d.ts

@@ -0,0 +1,3 @@
+export declare function shouldShowOnboarding(): boolean;
+export declare function runOnboarding(): Promise<boolean>;
+//# sourceMappingURL=onboarding.d.ts.map

package/dist/core/onboarding.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { configManager } from './config/config-manager.js';
+import { scanProviders, toEndpointConfig } from './config/auto-detect.js';
+import { CONFIG_FILE_PATH } from '../constants.js';
+import * as fs from 'fs';
+export function shouldShowOnboarding() {
+    if (!fs.existsSync(CONFIG_FILE_PATH))
+        return true;
+    return !configManager.hasEndpoints();
+}
+export async function runOnboarding() {
+    console.log();
+    console.log(chalk.cyan('  ╔══════════════════════════════════════════╗'));
+    console.log(chalk.cyan('  ║') + chalk.bold('   Welcome to Orquesta CLI! 🎵            ') + chalk.cyan('║'));
+    console.log(chalk.cyan('  ╚══════════════════════════════════════════╝'));
+    console.log();
+    console.log(chalk.dim('  Scanning for LLM providers...'));
+    console.log();
+    const result = await scanProviders();
+    if (result.detected.length === 0) {
+        console.log(chalk.yellow('  No LLM providers detected.'));
+        console.log();
+        console.log(chalk.dim('  To get started, do one of the following:'));
+        console.log(chalk.dim('    • Set an env var: OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.'));
+        console.log(chalk.dim('    • Start a local provider (Ollama on port 11434)'));
+        console.log(chalk.dim('    • Run: orquesta --add-provider <provider-id>'));
+        console.log();
+        return false;
+    }
+    let addedCount = 0;
+    for (const detected of result.detected) {
+        const endpoint = toEndpointConfig(detected);
+        await configManager.addEndpoint(endpoint);
+        addedCount++;
+        if (addedCount === 1 && endpoint.models.length > 0) {
+            await configManager.setCurrentEndpoint(endpoint.id);
+            await configManager.setCurrentModel(endpoint.models[0].id);
+        }
+    }
+    console.log(chalk.green(`  ✓ Auto-configured ${addedCount} provider(s):`));
+    for (const d of result.detected) {
+        const modelCount = d.discoveredModels.length;
+        console.log(chalk.white(`    • ${d.provider.name}`) + chalk.dim(` (${modelCount} model${modelCount !== 1 ? 's' : ''})`));
+    }
+    console.log();
+    return true;
+}
+//# sourceMappingURL=onboarding.js.map

package/dist/core/slash-command-handler.js

@@ -1,3 +1,4 @@
+import { commandRegistry } from './commands/index.js';
 import { sessionManager } from './session/session-manager.js';
 import { usageTracker } from './usage-tracker.js';
 import { logger } from '../utils/logger.js';
@@ -6,72 +7,24 @@ import { readHookConfig, writeHookFiles, disableHooks } from '../orquesta/hook-i
 import { checkForCliUpdate, runCliUpdate, setSkippedVersion } from '../utils/update-checker.js';
 import { createRequire } from 'module';
 import { configManager } from './config/config-manager.js';
-import { getForcedTier, setForcedTier, resetBatutaSession } from './routing-state.js';
+import { getForcedTier, setForcedTier } from './routing-state.js';
 import { auditLog } from '../orchestration/audit-log.js';
 import { remotePhone } from '../orquesta/remote-phone.js';
 export async function executeSlashCommand(command, context) {
     const trimmedCommand = command.trim();
     logger.enter('executeSlashCommand', { command: trimmedCommand });
+    const commandName = trimmedCommand.split(/\s/)[0];
+    const registryResult = await commandRegistry.execute(commandName, context, trimmedCommand);
+    if (registryResult) {
+        logger.exit('executeSlashCommand', { handled: true, command: commandName, source: 'registry' });
+        return registryResult;
+    }
     if (trimmedCommand === '/exit' || trimmedCommand === '/quit') {
         logger.flow('Exit command received');
         context.exit();
         logger.exit('executeSlashCommand', { handled: true, command: 'exit' });
         return { handled: true, shouldContinue: false };
     }
-    if (trimmedCommand === '/clear') {
-        logger.flow('Clear command - resetting messages and todos');
-        context.setMessages([]);
-        context.setTodos([]);
-        resetBatutaSession();
-        logger.exit('executeSlashCommand', { handled: true, command: 'clear' });
-        return {
-            handled: true,
-            shouldContinue: false,
-            updatedContext: {
-                messages: [],
-                todos: [],
-            },
-        };
-    }
-    if (trimmedCommand === '/compact') {
-        logger.flow('Compact command received');
-        if (context.onCompact) {
-            logger.flow('Executing compact callback');
-            const result = await context.onCompact();
-            logger.vars({ name: 'compactSuccess', value: result.success }, { name: 'originalCount', value: result.originalMessageCount }, { name: 'newCount', value: result.newMessageCount });
-            const compactMessage = result.success
-                ? `✅ Conversation compacted successfully. (${result.originalMessageCount} → ${result.newMessageCount} messages)`
-                : `❌ Compact failed: ${result.error}`;
-            const baseMessages = (result.success && result.compactedMessages)
-                ? result.compactedMessages
-                : context.messages;
-            const updatedMessages = [
-                ...baseMessages,
-                { role: 'assistant', content: compactMessage },
-            ];
-            context.setMessages(updatedMessages);
-            return {
-                handled: true,
-                shouldContinue: false,
-                updatedContext: {
-                    messages: updatedMessages,
-                },
-            };
-        }
-        const fallbackMessage = '/compact is only available in interactive mode.';
-        const updatedMessages = [
-            ...context.messages,
-            { role: 'assistant', content: fallbackMessage },
-        ];
-        context.setMessages(updatedMessages);
-        return {
-            handled: true,
-            shouldContinue: false,
-            updatedContext: {
-                messages: updatedMessages,
-            },
-        };
-    }
     if (trimmedCommand === '/settings') {
         if (context.onShowSettings) {
             context.onShowSettings();
@@ -626,50 +579,6 @@ ${executorLines}
             return reply(`❌ Could not open the remote phone channel: ${e.message}`);
         }
     }
-    if (trimmedCommand === '/help') {
-        const helpMessage = `
-Available commands:
-  /exit, /quit    - Exit the application
-  /clear          - Clear conversation and TODOs
-  /compact        - Compact conversation to free up context
-  /settings       - Open settings menu
-  /model          - Switch between LLM models
-  /project        - Switch between Orquesta projects
-  /tool           - Enable/disable optional tools (Browser, Background)
-  /load           - Load a saved session
-  /usage          - Show token usage statistics
-  /cost           - Estimated USD spend this process (by model)
-  /route          - Pin Batuta Auto tier (fast/balanced/premium/auto)
-  /sync           - Bidirectional sync with Orquesta dashboard (pull & push LLM configs)
-  /login          - Sign in to Orquesta via browser (opens getorquesta.com)
-  /logout         - Sign out of Orquesta (clears token, keeps local LLM configs)
-  /whoami         - Show current Orquesta connection
-  /hook           - Claude Code hook here: /hook status | enable | disable
-  /remote-phone   - Drive this session from your phone: on | off | status
-  /update         - Update orquesta-cli to the latest version
-
-Keyboard shortcuts:
-  Ctrl+C          - Exit
-  Ctrl+T          - Toggle TODO details
-  ESC             - Interrupt current execution
-  @               - File browser
-  /               - Command autocomplete
-
-Note: All conversations are automatically saved.
-    `;
-        const updatedMessages = [
-            ...context.messages,
-            { role: 'assistant', content: helpMessage },
-        ];
-        context.setMessages(updatedMessages);
-        return {
-            handled: true,
-            shouldContinue: false,
-            updatedContext: {
-                messages: updatedMessages,
-            },
-        };
-    }
     if (trimmedCommand.startsWith('/load')) {
         logger.flow('Load command received');
         const parts = trimmedCommand.split(' ');