orquesta-cli 0.2.13 → 0.2.15

package/dist/orchestration/plan-executor.js

@@ -3,7 +3,7 @@ import { sessionManager } from '../core/session/session-manager.js';
 import { CompactManager, contextTracker, buildCompactedMessages, } from '../core/compact/index.js';
 import { configManager } from '../core/config/config-manager.js';
 import { setTodoWriteCallback, clearTodoCallbacks, } from '../tools/llm/simple/todo-tools.js';
-import { setGetTodosCallback, setFinalResponseCallback, clearFinalResponseCallbacks, } from '../tools/llm/simple/final-response-tool.js';
+import { setGetTodosCallback, setFinalResponseCallback, setMarkTodosCompletedCallback, clearFinalResponseCallbacks, } from '../tools/llm/simple/final-response-tool.js';
 import { setDocsSearchLLMClientGetter, clearDocsSearchLLMClientGetter, } from '../tools/llm/simple/docs-search-agent-tool.js';
 import { emitPlanCreated, emitTodoStart, emitTodoComplete, emitTodoFail, emitCompact, emitAssistantResponse, } from '../tools/llm/simple/file-tools.js';
 import { toolRegistry } from '../tools/registry.js';
@@ -419,6 +419,20 @@ export class PlanExecutor {
         setFinalResponseCallback((message) => {
             emitAssistantResponse(message);
         });
+        setMarkTodosCompletedCallback(() => {
+            const completed = todosRef.map(t => t.status === 'completed' || t.status === 'failed'
+                ? t
+                : { ...t, status: 'completed' });
+            for (const t of completed) {
+                const old = todosRef.find(o => o.id === t.id);
+                if (old && old.status !== 'completed' && old.status !== 'failed') {
+                    emitTodoComplete(t.title);
+                }
+            }
+            todosRef = completed;
+            updateLocalTodos(completed);
+            callbacks.setTodos([...completed]);
+        });
     }
     async maybeRunRefiner(llmClient, currentMessages, currentTodos, callbacks) {
         if (!configManager.isRefinerEnabled())

package/dist/tools/llm/simple/final-response-tool.d.ts

@@ -3,6 +3,8 @@ import { ToolDefinition } from '../../../types/index.js';
 import { TodoItem } from '../../../types/index.js';
 export type GetTodosCallback = () => TodoItem[];
 export type FinalResponseCallback = (message: string) => void;
+export type MarkTodosCompletedCallback = () => void;
+export declare function setMarkTodosCompletedCallback(callback: MarkTodosCompletedCallback): void;
 export declare function setGetTodosCallback(callback: GetTodosCallback): void;
 export declare function setFinalResponseCallback(callback: FinalResponseCallback): void;
 export declare function clearFinalResponseCallbacks(): void;

package/dist/tools/llm/simple/final-response-tool.js

@@ -1,6 +1,10 @@
 import { logger } from '../../../utils/logger.js';
 let getTodosCallback = null;
 let finalResponseCallback = null;
+let markTodosCompletedCallback = null;
+export function setMarkTodosCompletedCallback(callback) {
+    markTodosCompletedCallback = callback;
+}
 export function setGetTodosCallback(callback) {
     logger.flow('Setting getTodos callback for final_response');
     getTodosCallback = callback;
@@ -13,19 +17,13 @@ export function clearFinalResponseCallbacks() {
     logger.flow('Clearing final response callbacks');
     getTodosCallback = null;
     finalResponseCallback = null;
+    markTodosCompletedCallback = null;
 }
 function areAllTodosCompleted(todos) {
     if (todos.length === 0)
         return true;
     return todos.every(t => t.status === 'completed' || t.status === 'failed');
 }
-function getIncompleteTodosSummary(todos) {
-    const incomplete = todos.filter(t => t.status !== 'completed' && t.status !== 'failed');
-    if (incomplete.length === 0)
-        return '';
-    const list = incomplete.map(t => `- [${t.status}] ${t.title}`).join('\n');
-    return `Incomplete TODOs:\n${list}`;
-}
 const FINAL_RESPONSE_DEFINITION = {
     type: 'function',
     function: {
@@ -76,15 +74,20 @@ async function executeFinalResponse(args) {
     }
     const todos = getTodosCallback();
     if (!areAllTodosCompleted(todos)) {
-        const incompleteSummary = getIncompleteTodosSummary(todos);
-        logger.flow('Final response rejected - incomplete TODOs');
-        logger.debug('Incomplete TODOs', { count: todos.filter(t => t.status !== 'completed' && t.status !== 'failed').length });
-        return {
-            success: false,
-            error: `Cannot deliver final response: Please complete all TODOs first.\n\n${incompleteSummary}\n\nMark each TODO as "completed" or "failed" using write_todos before calling final_response.`,
-        };
+        logger.flow('final_response with incomplete TODOs — auto-completing remaining and delivering');
+        logger.debug('Auto-completed TODOs', { count: todos.filter(t => t.status !== 'completed' && t.status !== 'failed').length });
+        if (markTodosCompletedCallback) {
+            try {
+                markTodosCompletedCallback();
+            }
+            catch (e) {
+                logger.warn(`markTodosCompleted failed: ${e}`);
+            }
+        }
+    }
+    else {
+        logger.flow('All TODOs completed - delivering final response');
     }
-    logger.flow('All TODOs completed - delivering final response');
     if (finalResponseCallback) {
         finalResponseCallback(message);
     }

package/dist/ui/TodoPanel.d.ts

@@ -13,6 +13,7 @@ export declare const TodoStatusBar: React.FC<{
         tokensUsed: number;
         tokenLimit: number;
     } | null;
+    isProcessing?: boolean;
 }>;
 export default TodoPanel;
 //# sourceMappingURL=TodoPanel.d.ts.map

package/dist/ui/TodoPanel.js

@@ -70,10 +70,10 @@ export const TodoPanel = React.memo(({ todos, currentTodoId, isProcessing = fals
             const isCompleted = todo.status === 'completed';
             return (React.createElement(Box, { key: todo.id, flexDirection: "column" },
                 React.createElement(Box, null,
-                    React.createElement(Box, { width: 2 }, isInProgress ? (React.createElement(Text, { color: "blueBright" },
+                    React.createElement(Box, { width: 2 }, isInProgress && isProcessing ? (React.createElement(Text, { color: "blueBright" },
                         React.createElement(Spinner, { type: "dots2" }))) : (React.createElement(Text, { color: config.color }, config.icon))),
                     React.createElement(Text, { color: isCompleted ? 'gray' : isInProgress ? 'white' : 'gray', bold: isInProgress, dimColor: isCompleted, strikethrough: isCompleted }, todo.title),
-                    isInProgress && (React.createElement(Text, { color: "blueBright" }, " \u2190"))),
+                    isInProgress && isProcessing && (React.createElement(Text, { color: "blueBright" }, " \u2190"))),
                 todo.error && (React.createElement(Box, { marginLeft: 2 },
                     React.createElement(Text, { color: "red", dimColor: true },
                         "\u26A0 ",
@@ -100,7 +100,7 @@ export const TodoPanel = React.memo(({ todos, currentTodoId, isProcessing = fals
     }
     return true;
 });
-export const TodoStatusBar = React.memo(({ todos, projectName, batutaUsage }) => {
+export const TodoStatusBar = React.memo(({ todos, projectName, batutaUsage, isProcessing = false }) => {
     useEffect(() => {
         logger.debug('TodoStatusBar rendered', { todoCount: todos.length });
     }, [todos.length]);
@@ -145,8 +145,8 @@ export const TodoStatusBar = React.memo(({ todos, projectName, batutaUsage }) =>
             todos.length),
         currentTodo && (React.createElement(React.Fragment, null,
             React.createElement(Text, { color: "white" }, " \u2502 "),
-            React.createElement(Text, { color: "blueBright" },
-                React.createElement(Spinner, { type: "dots" })),
+            isProcessing ? (React.createElement(Text, { color: "blueBright" },
+                React.createElement(Spinner, { type: "dots" }))) : (React.createElement(Text, { color: "gray" }, "\u2610")),
             React.createElement(Text, { color: "white" },
                 " ",
                 currentTodo.title.slice(0, 30),

package/dist/ui/components/PlanExecuteApp.js

@@ -36,6 +36,8 @@ import { closeJsonStreamLogger } from '../../utils/json-stream-logger.js';
 import { configManager } from '../../core/config/config-manager.js';
 import { logger } from '../../utils/logger.js';
 import { usageTracker } from '../../core/usage-tracker.js';
+import { UpdateNotification } from '../UpdateNotification.js';
+import { checkForCliUpdate, runCliUpdate } from '../../utils/update-checker.js';
 import { setToolExecutionCallback, setTellToUserCallback, setToolResponseCallback, setPlanCreatedCallback, setTodoStartCallback, setTodoCompleteCallback, setTodoFailCallback, setCompactCallback, setAssistantResponseCallback, setToolApprovalCallback, setReasoningCallback, } from '../../tools/llm/simple/file-tools.js';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
@@ -89,6 +91,10 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
     const [messages, setMessages] = useState([]);
     const { input, setInput, handleHistoryPrev, handleHistoryNext, addToHistory } = useInputHistory();
     const [isProcessing, setIsProcessing] = useState(false);
+    const [updatePhase, setUpdatePhase] = useState('hidden');
+    const [updateLatest, setUpdateLatest] = useState('');
+    const [updateProgress, setUpdateProgress] = useState('');
+    const [updateError, setUpdateError] = useState('');
     const planningMode = 'auto';
     const [llmClient, setLlmClient] = useState(initialLlmClient);
     const [activityType, setActivityType] = useState('thinking');
@@ -172,6 +178,16 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
             logger.exit('PlanExecuteApp', { messageCount: messages.length });
         };
     }, []);
+    useEffect(() => {
+        let cancelled = false;
+        checkForCliUpdate(VERSION).then(info => {
+            if (!cancelled && info) {
+                setUpdateLatest(info.latest);
+                setUpdatePhase('available');
+            }
+        });
+        return () => { cancelled = true; };
+    }, []);
     useEffect(() => {
         setToolExecutionCallback((toolName, reason, args) => {
             lastToolArgsRef.current = args;
@@ -488,6 +504,32 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
             logger.debug('Ctrl+C pressed - waiting for double-tap to exit');
             return;
         }
+        if (updatePhase === 'available' && !isProcessing && input.trim() === '') {
+            if (inputChar === 'y' || inputChar === 'Y') {
+                setUpdateError('');
+                setUpdateProgress('');
+                setUpdatePhase('updating');
+                runCliUpdate(updateLatest, (line) => setUpdateProgress(line.slice(0, 100)))
+                    .then(res => {
+                    if (res.success) {
+                        setUpdatePhase('done');
+                    }
+                    else {
+                        setUpdateError(res.error || 'Update failed');
+                        setUpdatePhase('error');
+                    }
+                });
+                return;
+            }
+            if (key.escape || inputChar === 'n' || inputChar === 'N' || inputChar === 's' || inputChar === 'S') {
+                setUpdatePhase('hidden');
+                return;
+            }
+        }
+        if ((updatePhase === 'done' || updatePhase === 'error') && key.escape) {
+            setUpdatePhase('hidden');
+            return;
+        }
         if (key.escape && (isProcessing || planExecutionState.isInterrupted)) {
             logger.flow('ESC pressed');
             if (llmClient) {
@@ -1260,6 +1302,14 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
         isDocsSearching && (React.createElement(DocsSearchProgress, { logs: docsSearchLogs, isSearching: isDocsSearching })),
         planExecutionState.todos.length > 0 && (React.createElement(Box, { marginTop: 2, marginBottom: 1 },
             React.createElement(TodoPanel, { todos: planExecutionState.todos, currentTodoId: planExecutionState.currentTodoId, isProcessing: isProcessing }))),
+        updatePhase === 'available' && (React.createElement(UpdateNotification, { currentVersion: VERSION, latestVersion: updateLatest })),
+        updatePhase === 'updating' && (React.createElement(UpdateNotification, { currentVersion: VERSION, latestVersion: updateLatest, isUpdating: true, updateProgress: updateProgress })),
+        updatePhase === 'error' && (React.createElement(UpdateNotification, { currentVersion: VERSION, latestVersion: updateLatest, error: updateError })),
+        updatePhase === 'done' && (React.createElement(Box, { borderStyle: "round", borderColor: "green", paddingX: 1, marginY: 1, flexDirection: "column" },
+            React.createElement(Text, { color: "green", bold: true },
+                "\u2705 Updated to orquesta-cli v",
+                updateLatest),
+            React.createElement(Text, { color: "gray" }, "Restart orquesta to use the new version. (Esc to dismiss)"))),
         React.createElement(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexDirection: "column" },
             React.createElement(Box, null,
                 React.createElement(Text, { color: "green", bold: true }, "> "),
@@ -1358,7 +1408,7 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
                 React.createElement(Text, { color: "gray" }, shortenPath(process.cwd())),
                 (planExecutionState.todos.length > 0 || batutaUsage) && (React.createElement(React.Fragment, null,
                     React.createElement(Text, { color: "gray" }, " \u2502 "),
-                    React.createElement(TodoStatusBar, { todos: planExecutionState.todos, projectName: configManager.getOrquestaConfig()?.projectName, batutaUsage: batutaUsage })))),
+                    React.createElement(TodoStatusBar, { todos: planExecutionState.todos, projectName: configManager.getOrquestaConfig()?.projectName, batutaUsage: batutaUsage, isProcessing: isProcessing })))),
             React.createElement(Text, { color: "gray", dimColor: true }, "Tab: mode \u2502 /help")))),
         showLogFiles && (React.createElement(Box, { marginTop: 0 },
             React.createElement(LogBrowser, { onClose: () => setShowLogFiles(false) })))));

package/dist/ui/hooks/slashCommandProcessor.js

@@ -20,6 +20,10 @@ export const SLASH_COMMANDS = [
         name: '/model',
         description: 'Switch between LLM models',
     },
+    {
+        name: '/route',
+        description: 'Pin Batuta Auto tier: auto | fast | balanced | premium',
+    },
     {
         name: '/sync',
         description: 'Sync LLM configs with Orquesta dashboard',

package/dist/utils/update-checker.d.ts

@@ -0,0 +1,9 @@
+export declare function checkForCliUpdate(currentVersion: string, timeoutMs?: number): Promise<{
+    current: string;
+    latest: string;
+} | null>;
+export declare function runCliUpdate(version: string, onProgress?: (line: string) => void): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+//# sourceMappingURL=update-checker.d.ts.map

package/dist/utils/update-checker.js

@@ -0,0 +1,65 @@
+import { spawn } from 'child_process';
+import { logger } from './logger.js';
+const REGISTRY_URL = 'https://registry.npmjs.org/orquesta-cli/latest';
+function isNewer(a, b) {
+    const pa = a.split('.').map(n => parseInt(n, 10) || 0);
+    const pb = b.split('.').map(n => parseInt(n, 10) || 0);
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] || 0) > (pb[i] || 0))
+            return true;
+        if ((pa[i] || 0) < (pb[i] || 0))
+            return false;
+    }
+    return false;
+}
+export async function checkForCliUpdate(currentVersion, timeoutMs = 3500) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        const res = await fetch(REGISTRY_URL, {
+            signal: controller.signal,
+            headers: { Accept: 'application/json' },
+        });
+        clearTimeout(timer);
+        if (!res.ok)
+            return null;
+        const json = (await res.json());
+        const latest = json?.version;
+        if (!latest || !isNewer(latest, currentVersion))
+            return null;
+        logger.debug?.('CLI update available', { current: currentVersion, latest });
+        return { current: currentVersion, latest };
+    }
+    catch {
+        return null;
+    }
+}
+export async function runCliUpdate(version, onProgress) {
+    return new Promise((resolve) => {
+        const child = spawn('npm', ['install', '-g', `orquesta-cli@${version}`], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let err = '';
+        child.stdout?.on('data', (d) => onProgress?.(d.toString().trim()));
+        child.stderr?.on('data', (d) => {
+            err += d.toString();
+            onProgress?.(d.toString().trim());
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve({ success: true });
+            }
+            else if (/EACCES|permission denied|not permitted|EPERM/i.test(err)) {
+                resolve({
+                    success: false,
+                    error: `Permission denied. Run manually: sudo npm install -g orquesta-cli@latest`,
+                });
+            }
+            else {
+                resolve({ success: false, error: err.slice(-300).trim() || `npm exited with code ${code}` });
+            }
+        });
+        child.on('error', (e) => resolve({ success: false, error: e.message }));
+    });
+}
+//# sourceMappingURL=update-checker.js.map

package/package.json

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