orquesta-cli 0.2.48 → 0.2.50

package/dist/core/embeddings-context.d.ts

@@ -0,0 +1,3 @@
+export declare function getRelevantContext(userMessage: string): string;
+export declare function resetEmbeddingsCache(): void;
+//# sourceMappingURL=embeddings-context.d.ts.map

package/dist/core/embeddings-context.js

@@ -0,0 +1,109 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { shouldIgnore } from './ignore-filter.js';
+const SOURCE_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py', '.rs', '.go', '.java', '.rb', '.vue', '.svelte',
+]);
+const SYMBOL_RE = /(?:function|class|interface|type|enum|const|let|var|export\s+(?:default\s+)?(?:function|class|const|let|async\s+function))\s+(\w+)/g;
+let indexCache = null;
+function scanDir(dir, entries, depth = 0) {
+    if (depth > 6)
+        return;
+    let items;
+    try {
+        items = fs.readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const item of items) {
+        const full = path.join(dir, item);
+        const rel = path.relative(process.cwd(), full);
+        if (shouldIgnore(rel))
+            continue;
+        let stat;
+        try {
+            stat = fs.statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isDirectory()) {
+            scanDir(full, entries, depth + 1);
+        }
+        else if (SOURCE_EXTENSIONS.has(path.extname(item))) {
+            try {
+                const content = fs.readFileSync(full, 'utf-8');
+                const lines = content.split('\n');
+                const symbols = [];
+                let m;
+                SYMBOL_RE.lastIndex = 0;
+                while ((m = SYMBOL_RE.exec(content)) !== null) {
+                    if (m[1])
+                        symbols.push(m[1]);
+                }
+                entries.set(rel, {
+                    path: rel,
+                    symbols,
+                    preview: lines.slice(0, 5).join('\n'),
+                });
+            }
+            catch { }
+        }
+    }
+}
+function getIndex() {
+    if (!indexCache) {
+        indexCache = new Map();
+        scanDir(process.cwd(), indexCache);
+    }
+    return indexCache;
+}
+export function getRelevantContext(userMessage) {
+    const index = getIndex();
+    if (index.size === 0)
+        return '';
+    const words = userMessage
+        .toLowerCase()
+        .split(/[\s\W]+/)
+        .filter(w => w.length > 2);
+    if (words.length === 0)
+        return '';
+    const scored = [];
+    for (const entry of index.values()) {
+        let score = 0;
+        const pathLower = entry.path.toLowerCase();
+        const symbolsLower = entry.symbols.map(s => s.toLowerCase());
+        for (const word of words) {
+            if (pathLower.includes(word))
+                score += 2;
+            for (const sym of symbolsLower) {
+                if (sym.includes(word))
+                    score += 3;
+            }
+        }
+        if (score > 0)
+            scored.push({ entry, score });
+    }
+    if (scored.length === 0)
+        return '';
+    scored.sort((a, b) => b.score - a.score);
+    const top = scored.slice(0, 5);
+    const sections = top.map(({ entry }) => {
+        let preview;
+        try {
+            const content = fs.readFileSync(path.resolve(process.cwd(), entry.path), 'utf-8');
+            preview = content.split('\n').slice(0, 20).join('\n');
+        }
+        catch {
+            preview = entry.preview;
+        }
+        return `File: ${entry.path}\nSymbols: ${entry.symbols.join(', ')}\nPreview:\n${preview.split('\n').map(l => '  ' + l).join('\n')}`;
+    });
+    return `\n<relevant_files>\n${sections.join('\n\n')}\n</relevant_files>`;
+}
+export function resetEmbeddingsCache() {
+    indexCache = null;
+}
+//# sourceMappingURL=embeddings-context.js.map

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

@@ -203,6 +203,16 @@ 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 });
+            let systemCached = false;
+            for (const msg of processedMessages) {
+                if (!systemCached && msg.role === 'system') {
+                    msg.cache_control = { type: 'ephemeral' };
+                    systemCached = true;
+                }
+                else if (msg.role === 'user' && typeof msg.content === 'string' && msg.content.length > 2000) {
+                    msg.cache_control = { type: 'ephemeral' };
+                }
+            }
             const isClaudeModel = /claude|sonnet|opus|haiku/i.test(modelId);
             const requestBody = {
                 model: modelId,

package/dist/core/session/session-manager.js

@@ -4,6 +4,7 @@ import { configManager } from '../config/config-manager.js';
 import { PROJECTS_DIR, cwdToProjectSegment } from '../../constants.js';
 import { initializeJsonStreamLogger } from '../../utils/json-stream-logger.js';
 import { logger } from '../../utils/logger.js';
+import { scheduleSessionSync } from '../../orquesta/session-sync.js';
 export class SessionManager {
     currentSessionId = null;
     currentSessionCreatedAt = null;
@@ -233,6 +234,7 @@ export class SessionManager {
             const sessionsDir = this.getSessionsDir();
             const filePath = path.join(sessionsDir, `${this.currentSessionId}.json`);
             await fs.writeFile(filePath, JSON.stringify(sessionData, null, 2), 'utf-8');
+            scheduleSessionSync(this.currentSessionId, normalizedMessages);
         }
         finally {
             this.isSaving = false;

package/dist/core/sub-agent.d.ts

@@ -0,0 +1,14 @@
+export interface SubAgentResult {
+    success: boolean;
+    output: string;
+    error?: string;
+}
+export declare function spawnSubAgent(task: string, options?: {
+    cwd?: string;
+    timeout?: number;
+}): Promise<SubAgentResult>;
+export declare function spawnSubAgentsParallel(tasks: Array<{
+    task: string;
+    cwd?: string;
+}>, maxConcurrent?: number): Promise<SubAgentResult[]>;
+//# sourceMappingURL=sub-agent.d.ts.map

package/dist/core/sub-agent.js

@@ -0,0 +1,27 @@
+import { execSync } from 'child_process';
+export async function spawnSubAgent(task, options) {
+    const cwd = options?.cwd || process.cwd();
+    const timeout = options?.timeout || 120000;
+    try {
+        const output = execSync(`orquesta -p '${task.replace(/'/g, "'\\''")}'  --dangerously-skip-permissions`, { cwd, timeout, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        return { success: true, output: output.trim() };
+    }
+    catch (err) {
+        const error = err;
+        return {
+            success: false,
+            output: error.stdout?.trim() || '',
+            error: error.stderr?.trim() || error.message || 'Unknown error',
+        };
+    }
+}
+export async function spawnSubAgentsParallel(tasks, maxConcurrent = 3) {
+    const results = [];
+    for (let i = 0; i < tasks.length; i += maxConcurrent) {
+        const batch = tasks.slice(i, i + maxConcurrent);
+        const batchResults = await Promise.all(batch.map(t => spawnSubAgent(t.task, { cwd: t.cwd })));
+        results.push(...batchResults);
+    }
+    return results;
+}
+//# sourceMappingURL=sub-agent.js.map

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.js

@@ -16,6 +16,7 @@ import { GIT_COMMIT_RULES } from '../prompts/shared/git-rules.js';
 import { logger } from '../utils/logger.js';
 import { getStreamLogger } from '../utils/json-stream-logger.js';
 import { detectGitRepo } from '../utils/git-utils.js';
+import { getRelevantContext } from '../core/embeddings-context.js';
 import { formatErrorMessage, buildTodoContext, findActiveTodo, getTodoStats } from './utils.js';
 import { BaseError } from '../errors/base.js';
 import { runParallelGraph, shouldUseParallelOrchestrator } from './parallel-orchestrator.js';
@@ -146,8 +147,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
@@ -169,8 +170,9 @@ export class PlanExecutor {
             const tools = toolRegistry.getLLMToolDefinitions();
             const hasSystemMessage = currentMessages.some(m => m.role === 'system');
             if (!hasSystemMessage) {
+                const relevantContext = getRelevantContext(userMessage);
                 currentMessages = [
-                    { role: 'system', content: this.getSystemPrompt() },
+                    { role: 'system', content: this.getSystemPrompt() + relevantContext },
                     ...currentMessages
                 ];
             }
@@ -318,8 +320,9 @@ export class PlanExecutor {
             const tools = toolRegistry.getLLMToolDefinitions();
             const hasSystemMessage = currentMessages.some(m => m.role === 'system');
             if (!hasSystemMessage) {
+                const relevantContext = getRelevantContext(userMessage);
                 currentMessages = [
-                    { role: 'system', content: this.getSystemPrompt() },
+                    { role: 'system', content: this.getSystemPrompt() + relevantContext },
                     ...currentMessages
                 ];
             }

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/orquesta/session-sync.d.ts

@@ -0,0 +1,3 @@
+import { Message } from '../types/index.js';
+export declare function scheduleSessionSync(sessionId: string, messages: Message[]): void;
+//# sourceMappingURL=session-sync.d.ts.map

package/dist/orquesta/session-sync.js

@@ -0,0 +1,31 @@
+import { configManager } from '../core/config/config-manager.js';
+const ORQUESTA_API = process.env['ORQUESTA_API_URL'] || 'https://getorquesta.com';
+let syncTimeout = null;
+export function scheduleSessionSync(sessionId, messages) {
+    if (syncTimeout)
+        clearTimeout(syncTimeout);
+    syncTimeout = setTimeout(() => doSync(sessionId, messages), 5000);
+}
+async function doSync(sessionId, messages) {
+    const config = configManager.getOrquestaConfig();
+    if (!config?.token)
+        return;
+    try {
+        await fetch(`${ORQUESTA_API}/api/sessions/sync`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config.token}`,
+            },
+            body: JSON.stringify({
+                sessionId,
+                messages: messages.map(m => ({ role: m.role, content: m.content?.slice(0, 10000) })),
+                cwd: process.cwd(),
+                model: configManager.getCurrentModel()?.id,
+                updatedAt: new Date().toISOString(),
+            }),
+        });
+    }
+    catch { }
+}
+//# sourceMappingURL=session-sync.js.map

package/dist/tools/llm/simple/sub-agent-tool.d.ts

@@ -0,0 +1,3 @@
+import { LLMSimpleTool } from '../../types.js';
+export declare const SpawnSubAgentTool: LLMSimpleTool;
+//# sourceMappingURL=sub-agent-tool.d.ts.map

package/dist/tools/llm/simple/sub-agent-tool.js

@@ -0,0 +1,37 @@
+import { spawnSubAgent } from '../../../core/sub-agent.js';
+const SUB_AGENT_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'spawn_sub_agent',
+        description: 'Spawn a sub-agent to handle a specific task in parallel. Use for independent sub-tasks that can run concurrently.',
+        parameters: {
+            type: 'object',
+            properties: {
+                task: {
+                    type: 'string',
+                    description: 'The task description to pass to the sub-agent',
+                },
+                cwd: {
+                    type: 'string',
+                    description: 'Working directory for the sub-agent (optional, defaults to current directory)',
+                },
+            },
+            required: ['task'],
+        },
+    },
+};
+async function executeSpawnSubAgent(args) {
+    const task = args['task'];
+    const cwd = args['cwd'];
+    const result = await spawnSubAgent(task, { cwd });
+    if (result.success) {
+        return { success: true, result: result.output };
+    }
+    return { success: false, result: result.output, error: result.error };
+}
+export const SpawnSubAgentTool = {
+    definition: SUB_AGENT_DEFINITION,
+    execute: executeSpawnSubAgent,
+    categories: ['llm-simple'],
+};
+//# sourceMappingURL=sub-agent-tool.js.map

package/dist/tools/registry.js

@@ -8,6 +8,7 @@ import { TODO_TOOLS } from './llm/simple/todo-tools.js';
 import { PLANNING_TOOLS } from './llm/simple/planning-tools.js';
 import { FinalResponseTool } from './llm/simple/final-response-tool.js';
 import { RemotePhoneTool } from './llm/simple/remote-phone-tool.js';
+import { SpawnSubAgentTool } from './llm/simple/sub-agent-tool.js';
 import { getShellTools } from './llm/simple/index.js';
 let _browserTools = null;
 let _startBrowserServer = null;
@@ -316,6 +317,7 @@ export function initializeToolRegistry() {
     toolRegistry.registerAll(TODO_TOOLS);
     toolRegistry.register(FinalResponseTool);
     toolRegistry.register(RemotePhoneTool);
+    toolRegistry.register(SpawnSubAgentTool);
     toolRegistry.registerAll(PLANNING_TOOLS);
 }
 export async function initializeOptionalTools() {

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) => {
@@ -1321,8 +1321,24 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
                         React.createElement(Text, { color: "yellow" }, "\uD83D\uDCAD "),
                         React.createElement(Text, { color: "white", dimColor: true }, truncatedReason)))));
             }
-            case 'tool_result':
-                return null;
+            case 'tool_result': {
+                if (!entry.diff || entry.diff.length === 0)
+                    return null;
+                let filePath = '';
+                try {
+                    filePath = JSON.parse(entry.details || '{}').file || '';
+                }
+                catch { }
+                const header = filePath ? `┌─ ${filePath} ─` : '┌─';
+                return (React.createElement(Box, { key: entry.id, flexDirection: "column", marginLeft: 2 },
+                    React.createElement(Text, { color: "gray" },
+                        header,
+                        '─'.repeat(Math.max(0, 32 - header.length))),
+                    entry.diff.map((line, i) => (React.createElement(Text, { key: i, color: line.startsWith('+') ? 'green' : line.startsWith('-') ? 'red' : 'gray' },
+                        '│ ',
+                        line))),
+                    React.createElement(Text, { color: "gray" }, '└' + '─'.repeat(32))));
+            }
             case 'shell_result': {
                 const SHELL_MAX_LINES = 8;
                 const allLines = (entry.content || '').split('\n');

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.48",
+  "version": "0.2.50",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",