orquesta-cli 0.2.49 → 0.2.51

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/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';
@@ -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/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/PlanExecuteApp.js

@@ -290,14 +290,23 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
         };
     }, [addLog]);
     useEffect(() => {
-        if (llmClient) {
-            llmClient.onStreamingContent = (token) => {
-                setStreamingText(prev => prev + token);
-            };
-        }
+        if (!llmClient)
+            return;
+        let buffer = '';
+        let rafId = null;
+        llmClient.onStreamingContent = (token) => {
+            buffer += token;
+            if (!rafId) {
+                rafId = setTimeout(() => {
+                    setStreamingText(buffer);
+                    rafId = null;
+                }, 80);
+            }
+        };
         return () => {
-            if (llmClient)
-                llmClient.onStreamingContent = null;
+            if (rafId)
+                clearTimeout(rafId);
+            llmClient.onStreamingContent = null;
         };
     }, [llmClient]);
     useEffect(() => {
@@ -1321,8 +1330,25 @@ 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 diffLines = entry.diff.length > 10 ? [...entry.diff.slice(0, 10), `... +${entry.diff.length - 10} more lines`] : entry.diff;
+                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))),
+                    diffLines.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');
@@ -1423,7 +1449,7 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
         isProcessing && (planExecutionState.executionPhase === 'planning' || planExecutionState.todos.length === 0) && !pendingToolApproval && !isDocsSearching && (React.createElement(Box, { marginY: 1, flexDirection: "column" },
             React.createElement(ActivityIndicator, { activity: getCurrentActivityType(), startTime: activityStartTime, detail: activityDetail, subActivities: subActivities, modelName: currentModelInfo.model }),
             streamingText && (React.createElement(Box, { marginTop: 1, paddingX: 1 },
-                React.createElement(Text, { wrap: "wrap" }, streamingText))))),
+                React.createElement(Text, { wrap: "wrap" }, streamingText.split('\n').slice(-15).join('\n')))))),
         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 }))),

package/package.json

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