orquesta-cli 0.2.45 → 0.2.47

package/dist/agents/planner/index.js

@@ -3,6 +3,7 @@ import { buildPlanningSystemPrompt } from '../../prompts/agents/planning.js';
 import { toolRegistry } from '../../tools/registry.js';
 import { getProjectContext } from '../../core/project-context.js';
 import { getMemoryPrompt } from '../../core/memory.js';
+import { getGitContextPrompt } from '../../core/git-context.js';
 export class PlanningLLM {
     llmClient;
     askUserCallback = null;
@@ -23,7 +24,7 @@ export class PlanningLLM {
         const toolSummary = toolRegistry.getToolSummaryForPlanning();
         const optionalToolsInfo = toolRegistry.getEnabledOptionalToolsInfo();
         const projectContext = getProjectContext();
-        const systemPrompt = buildPlanningSystemPrompt(toolSummary, optionalToolsInfo) + projectContext + getMemoryPrompt();
+        const systemPrompt = buildPlanningSystemPrompt(toolSummary, optionalToolsInfo) + projectContext + getMemoryPrompt() + getGitContextPrompt();
         const clarificationMessages = [];
         const messages = [
             {

package/dist/cli.js

@@ -28,6 +28,7 @@ import { connectWithToken, showConnectionStatus, disconnectFromOrquesta, switchP
 import { syncOrquestaConfigs } from './orquesta/config-sync.js';
 import { scanProviders, scanProvider, toEndpointConfig } from './core/config/auto-detect.js';
 import { PROVIDERS } from './core/config/providers.js';
+import { shouldShowOnboarding, runOnboarding } from './core/onboarding.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
 const program = new Command();
@@ -75,7 +76,7 @@ program
     .name('orquesta')
     .description('Orquesta CLI - AI-powered coding assistant with local LLM support')
     .version(packageJson.version)
-    .helpOption(false);
+    .helpOption('-h, --help', 'Show help');
 program
     .option('-p, --print <prompt>', 'Execute a prompt and exit (non-interactive mode)')
     .option('--dangerously-skip-permissions', 'Skip all permission prompts (auto-approve)')
@@ -96,6 +97,7 @@ program
     .option('--init', 'Enable the Claude Code hook in this directory (reuses your login; or pass --token)')
     .option('--disable-hook', 'Disable the Claude Code hook in this directory')
     .option('--update', 'Update orquesta-cli to the latest published version and exit')
+    .option('-c, --continue', 'Resume the most recent conversation session')
     .action(async (options) => {
     if (options.appendSystemPrompt) {
         setAppendedSystemPrompt(options.appendSystemPrompt);
@@ -118,6 +120,9 @@ program
         return;
     }
     await configManager.initialize();
+    if (shouldShowOnboarding()) {
+        await runOnboarding();
+    }
     if (options.status) {
         showConnectionStatus();
         return;
@@ -273,24 +278,19 @@ program
             nodeVersion: process.version,
         });
         logger.flow('Config manager already initialized');
-        spinner.text = chalk.cyan('Loading tools...');
-        logger.flow('Initializing optional tools');
-        await initializeOptionalTools();
-        logger.flow('Optional tools initialized');
-        if (configManager.hasOrquestaConnection() && configManager.shouldAutoSync()) {
-            spinner.text = chalk.cyan('Syncing with Orquesta...');
-            logger.flow('Auto-syncing with Orquesta');
-            try {
-                const syncResult = await syncOrquestaConfigs();
+        spinner.text = chalk.cyan('Loading...');
+        const toolsPromise = initializeOptionalTools().then(() => {
+            logger.flow('Optional tools initialized');
+        });
+        const syncPromise = (configManager.hasOrquestaConnection() && configManager.shouldAutoSync())
+            ? syncOrquestaConfigs().then(syncResult => {
                 if (syncResult.success && (syncResult.added > 0 || syncResult.updated > 0)) {
                     logger.flow('Orquesta sync complete', { added: syncResult.added, updated: syncResult.updated });
                 }
-            }
-            catch (error) {
+            }).catch(error => {
                 logger.warn('Orquesta sync failed', { error: error instanceof Error ? error.message : String(error) });
-            }
-        }
-        spinner.text = chalk.cyan('Connecting to LLM...');
+            })
+            : Promise.resolve();
         let llmClient = null;
         let modelInfo = { model: 'Not configured', endpoint: 'Not configured' };
         if (configManager.hasEndpoints()) {
@@ -307,13 +307,14 @@ program
         else {
             logger.flow('No LLM endpoints configured');
         }
+        await Promise.all([toolsPromise, syncPromise]);
         spinner.stop();
         process.stdout.write('\x1B[2J\x1B[0f');
         if (options.verbose || options.debug) {
             console.log(chalk.cyan('Starting Orquesta CLI...\n'));
         }
         try {
-            const { waitUntilExit } = render(React.createElement(PlanExecuteApp, { llmClient, modelInfo }), { exitOnCtrlC: false });
+            const { waitUntilExit } = render(React.createElement(PlanExecuteApp, { llmClient, modelInfo, resumeLastSession: !!options.continue }), { exitOnCtrlC: false });
             await waitUntilExit();
         }
         catch (error) {

package/dist/constants.d.ts

@@ -5,5 +5,5 @@ export declare const DOCS_DIR: string;
 export declare const BACKUPS_DIR: string;
 export declare const PROJECTS_DIR: string;
 export declare function cwdToProjectSegment(cwd?: string): string;
-export declare const APP_VERSION = "4.2.2";
+export declare const APP_VERSION = "0.2.45";
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -12,5 +12,5 @@ export function cwdToProjectSegment(cwd = process.cwd()) {
         .replace(/[:*?"<>|]/g, '')
         .replace(/^-+/, '');
 }
-export const APP_VERSION = '4.2.2';
+export const APP_VERSION = '0.2.45';
 //# sourceMappingURL=constants.js.map

package/dist/core/commands/clear.d.ts

@@ -0,0 +1,3 @@
+import { SlashCommand } from './types.js';
+export declare const clearCommand: SlashCommand;
+//# sourceMappingURL=clear.d.ts.map

package/dist/core/commands/clear.js

@@ -0,0 +1,22 @@
+import { logger } from '../../utils/logger.js';
+import { resetBatutaSession } from '../routing-state.js';
+export const clearCommand = {
+    name: '/clear',
+    description: 'Clear conversation and TODOs',
+    async execute(context, _rawInput) {
+        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: [],
+            },
+        };
+    },
+};
+//# sourceMappingURL=clear.js.map

package/dist/core/commands/compact.d.ts

@@ -0,0 +1,3 @@
+import { SlashCommand } from './types.js';
+export declare const compactCommand: SlashCommand;
+//# sourceMappingURL=compact.d.ts.map

package/dist/core/commands/compact.js

@@ -0,0 +1,45 @@
+import { logger } from '../../utils/logger.js';
+export const compactCommand = {
+    name: '/compact',
+    description: 'Compact conversation to free up context',
+    async execute(context, _rawInput) {
+        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,
+            },
+        };
+    },
+};
+//# sourceMappingURL=compact.js.map

package/dist/core/commands/help.d.ts

@@ -0,0 +1,3 @@
+import { SlashCommand } from './types.js';
+export declare const helpCommand: SlashCommand;
+//# sourceMappingURL=help.d.ts.map

package/dist/core/commands/help.js

@@ -0,0 +1,50 @@
+export const helpCommand = {
+    name: '/help',
+    description: 'Show available commands',
+    async execute(context, _rawInput) {
+        const helpMessage = `
+Available commands:
+  /exit, /quit    - Exit the application
+  /clear          - Clear conversation and TODOs
+  /compact        - Compact conversation to free up context
+  /memory         - Persistent memory: /memory add <note> | list | remove <n> | clear
+  /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,
+            },
+        };
+    },
+};
+//# sourceMappingURL=help.js.map

package/dist/core/commands/index.d.ts

@@ -0,0 +1,3 @@
+export { commandRegistry } from './registry.js';
+export type { SlashCommand, CommandContext, CommandResult } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/commands/index.js

@@ -0,0 +1,11 @@
+import { commandRegistry } from './registry.js';
+import { clearCommand } from './clear.js';
+import { compactCommand } from './compact.js';
+import { memoryCommand } from './memory.js';
+import { helpCommand } from './help.js';
+commandRegistry.register(clearCommand);
+commandRegistry.register(compactCommand);
+commandRegistry.register(memoryCommand);
+commandRegistry.register(helpCommand);
+export { commandRegistry } from './registry.js';
+//# sourceMappingURL=index.js.map

package/dist/core/commands/memory.d.ts

@@ -0,0 +1,3 @@
+import { SlashCommand } from './types.js';
+export declare const memoryCommand: SlashCommand;
+//# sourceMappingURL=memory.d.ts.map

package/dist/core/commands/memory.js

@@ -0,0 +1,40 @@
+import { addMemory, removeMemory, clearMemory, listMemory } from '../memory.js';
+export const memoryCommand = {
+    name: '/memory',
+    description: 'Persistent memory: /memory add <note> | list | remove <n> | clear',
+    async execute(context, rawInput) {
+        const sub = rawInput.slice('/memory'.length).trim();
+        const reply = (content) => {
+            const updatedMessages = [...context.messages, { role: 'assistant', content }];
+            context.setMessages(updatedMessages);
+            return { handled: true, shouldContinue: false, updatedContext: { messages: updatedMessages } };
+        };
+        if (sub.startsWith('add ')) {
+            const note = sub.slice(4).trim();
+            if (!note)
+                return reply('Usage: /memory add <note>');
+            addMemory(note);
+            return reply(`✓ Saved to memory: "${note}"`);
+        }
+        if (sub === 'list' || sub === '') {
+            const entries = listMemory();
+            if (entries.length === 0)
+                return reply('Memory is empty. Use `/memory add <note>` to save preferences.');
+            const list = entries.map((e, i) => `  ${i + 1}. ${e}`).join('\n');
+            return reply(`📝 User memory (${entries.length} entries):\n${list}\n\nCommands: /memory add <note> | remove <n> | clear`);
+        }
+        if (sub.startsWith('remove ')) {
+            const idx = parseInt(sub.slice(7).trim(), 10);
+            if (isNaN(idx))
+                return reply('Usage: /memory remove <number>');
+            const ok = removeMemory(idx);
+            return reply(ok ? `✓ Removed entry #${idx}` : `Entry #${idx} not found`);
+        }
+        if (sub === 'clear') {
+            clearMemory();
+            return reply('✓ Memory cleared');
+        }
+        return reply('Usage: /memory add <note> | list | remove <n> | clear');
+    },
+};
+//# sourceMappingURL=memory.js.map

package/dist/core/commands/registry.d.ts

@@ -0,0 +1,11 @@
+import { SlashCommand, CommandContext, CommandResult } from './types.js';
+declare class CommandRegistry {
+    private commands;
+    register(command: SlashCommand): void;
+    get(name: string): SlashCommand | undefined;
+    execute(commandName: string, context: CommandContext, rawInput: string): Promise<CommandResult | null>;
+    getAll(): SlashCommand[];
+}
+export declare const commandRegistry: CommandRegistry;
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/core/commands/registry.js

@@ -0,0 +1,25 @@
+class CommandRegistry {
+    commands = new Map();
+    register(command) {
+        this.commands.set(command.name, command);
+        if (command.aliases) {
+            for (const alias of command.aliases) {
+                this.commands.set(alias, command);
+            }
+        }
+    }
+    get(name) {
+        return this.commands.get(name);
+    }
+    async execute(commandName, context, rawInput) {
+        const command = this.commands.get(commandName);
+        if (!command)
+            return null;
+        return command.execute(context, rawInput);
+    }
+    getAll() {
+        return [...new Set(this.commands.values())];
+    }
+}
+export const commandRegistry = new CommandRegistry();
+//# sourceMappingURL=registry.js.map

package/dist/core/commands/types.d.ts

@@ -0,0 +1,10 @@
+import { CommandHandlerContext, CommandExecutionResult } from '../slash-command-handler.js';
+export type CommandContext = CommandHandlerContext;
+export type CommandResult = CommandExecutionResult;
+export interface SlashCommand {
+    name: string;
+    aliases?: string[];
+    description: string;
+    execute(context: CommandContext, rawInput: string): Promise<CommandResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/commands/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/event-bus.d.ts

@@ -0,0 +1,20 @@
+type EventHandler<T = unknown> = (data: T) => void;
+declare class EventBus {
+    private handlers;
+    on<T>(event: string, handler: EventHandler<T>): () => void;
+    emit<T>(event: string, data: T): void;
+    off(event: string, handler: EventHandler): void;
+    clear(): void;
+}
+export declare const eventBus: EventBus;
+export declare const Events: {
+    readonly TOOL_START: "tool:start";
+    readonly TOOL_RESULT: "tool:result";
+    readonly TODO_UPDATE: "todo:update";
+    readonly STREAMING_TOKEN: "streaming:token";
+    readonly MODEL_CHANGED: "model:changed";
+    readonly SESSION_SAVED: "session:saved";
+    readonly FINAL_RESPONSE: "final:response";
+};
+export {};
+//# sourceMappingURL=event-bus.d.ts.map

package/dist/core/event-bus.js

@@ -0,0 +1,35 @@
+class EventBus {
+    handlers = new Map();
+    on(event, handler) {
+        if (!this.handlers.has(event)) {
+            this.handlers.set(event, new Set());
+        }
+        this.handlers.get(event).add(handler);
+        return () => this.off(event, handler);
+    }
+    emit(event, data) {
+        const handlers = this.handlers.get(event);
+        if (handlers) {
+            for (const handler of handlers) {
+                handler(data);
+            }
+        }
+    }
+    off(event, handler) {
+        this.handlers.get(event)?.delete(handler);
+    }
+    clear() {
+        this.handlers.clear();
+    }
+}
+export const eventBus = new EventBus();
+export const Events = {
+    TOOL_START: 'tool:start',
+    TOOL_RESULT: 'tool:result',
+    TODO_UPDATE: 'todo:update',
+    STREAMING_TOKEN: 'streaming:token',
+    MODEL_CHANGED: 'model:changed',
+    SESSION_SAVED: 'session:saved',
+    FINAL_RESPONSE: 'final:response',
+};
+//# sourceMappingURL=event-bus.js.map

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

@@ -0,0 +1,11 @@
+interface GitContext {
+    branch: string;
+    staged: string[];
+    unstaged: string[];
+    untracked: string[];
+    diffSummary: string;
+}
+export declare function getGitContext(): GitContext | null;
+export declare function getGitContextPrompt(): string;
+export {};
+//# sourceMappingURL=git-context.d.ts.map

package/dist/core/git-context.js

@@ -0,0 +1,62 @@
+import { execSync } from 'child_process';
+import { detectGitRepo } from '../utils/git-utils.js';
+const MAX_DIFF_CHARS = 8000;
+function run(cmd) {
+    try {
+        return execSync(cmd, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+export function getGitContext() {
+    if (!detectGitRepo())
+        return null;
+    const branch = run('git branch --show-current') || 'HEAD';
+    const statusOutput = run('git status --porcelain');
+    if (!statusOutput)
+        return { branch, staged: [], unstaged: [], untracked: [], diffSummary: '' };
+    const staged = [];
+    const unstaged = [];
+    const untracked = [];
+    for (const line of statusOutput.split('\n')) {
+        if (!line)
+            continue;
+        const x = line[0], y = line[1];
+        const file = line.slice(3);
+        if (x === '?') {
+            untracked.push(file);
+            continue;
+        }
+        if (x !== ' ' && x !== '?')
+            staged.push(file);
+        if (y !== ' ' && y !== '?')
+            unstaged.push(file);
+    }
+    let diffSummary = run('git diff --stat HEAD 2>/dev/null');
+    if (diffSummary.length > MAX_DIFF_CHARS) {
+        diffSummary = diffSummary.slice(0, MAX_DIFF_CHARS) + '\n[...truncated]';
+    }
+    return { branch, staged, unstaged, untracked, diffSummary };
+}
+export function getGitContextPrompt() {
+    const ctx = getGitContext();
+    if (!ctx)
+        return '';
+    const totalChanged = ctx.staged.length + ctx.unstaged.length + ctx.untracked.length;
+    if (totalChanged === 0)
+        return '';
+    const parts = ['\n\n<git_context>', `Branch: ${ctx.branch}`];
+    if (ctx.staged.length > 0) {
+        parts.push(`Staged (${ctx.staged.length}): ${ctx.staged.slice(0, 15).join(', ')}${ctx.staged.length > 15 ? '...' : ''}`);
+    }
+    if (ctx.unstaged.length > 0) {
+        parts.push(`Modified (${ctx.unstaged.length}): ${ctx.unstaged.slice(0, 15).join(', ')}${ctx.unstaged.length > 15 ? '...' : ''}`);
+    }
+    if (ctx.untracked.length > 0) {
+        parts.push(`Untracked (${ctx.untracked.length}): ${ctx.untracked.slice(0, 10).join(', ')}${ctx.untracked.length > 10 ? '...' : ''}`);
+    }
+    parts.push('</git_context>');
+    return parts.join('\n');
+}
+//# sourceMappingURL=git-context.js.map

package/dist/core/ignore-filter.d.ts

@@ -0,0 +1,4 @@
+export declare function getIgnorePatterns(): string[];
+export declare function shouldIgnore(filePath: string): boolean;
+export declare function resetIgnoreCache(): void;
+//# sourceMappingURL=ignore-filter.d.ts.map

package/dist/core/ignore-filter.js

@@ -0,0 +1,50 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { minimatch } from 'minimatch';
+let patterns = null;
+function loadPatterns() {
+    if (patterns !== null)
+        return patterns;
+    const cwd = process.cwd();
+    const orquestaIgnore = path.join(cwd, '.orquestaignore');
+    const gitIgnore = path.join(cwd, '.gitignore');
+    let content = '';
+    try {
+        content = fs.readFileSync(orquestaIgnore, 'utf-8');
+    }
+    catch {
+        try {
+            content = fs.readFileSync(gitIgnore, 'utf-8');
+        }
+        catch {
+            patterns = [];
+            return patterns;
+        }
+    }
+    patterns = content
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line.length > 0 && !line.startsWith('#'));
+    return patterns;
+}
+export function getIgnorePatterns() {
+    return loadPatterns();
+}
+export function shouldIgnore(filePath) {
+    const pats = loadPatterns();
+    const rel = path.relative(process.cwd(), path.resolve(filePath)).replace(/\\/g, '/');
+    for (const pat of pats) {
+        if (minimatch(rel, pat, { dot: true }) || minimatch(rel, `${pat}/**`, { dot: true })) {
+            return true;
+        }
+        const basename = path.basename(rel);
+        if (!pat.includes('/') && minimatch(basename, pat, { dot: true })) {
+            return true;
+        }
+    }
+    return false;
+}
+export function resetIgnoreCache() {
+    patterns = null;
+}
+//# sourceMappingURL=ignore-filter.js.map

package/dist/core/llm/llm-client.d.ts

@@ -45,6 +45,7 @@ export declare class LLMClient {
     private modelName;
     private currentAbortController;
     private isInterrupted;
+    onStreamingContent: ((token: string) => void) | null;
     private static readonly DEFAULT_MAX_RETRIES;
     constructor();
     private preprocessMessages;