@waqas/orch 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import Pastel from 'pastel';
+const app = new Pastel({
+    importMeta: import.meta,
+});
+await app.run();

package/dist/commands/index.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function Index(): React.JSX.Element;

package/dist/commands/index.js

@@ -0,0 +1,303 @@
+import React, { useEffect, useRef, useState } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { loadConfig } from '../core/config.js';
+import { formatMarkdown } from '../core/markdown.js';
+import { route, routeStreaming } from '../core/router.js';
+function Prompt({ value, cursor }) {
+    const before = value.slice(0, cursor);
+    const at = value[cursor] ?? ' ';
+    const after = value.slice(cursor + 1);
+    const isEmpty = value.length === 0;
+    return (React.createElement(Box, { borderStyle: "round", borderColor: "gray", width: "100%", paddingX: 1 }, isEmpty ? (React.createElement(Text, { dimColor: true }, "Type a message...")) : (React.createElement(Text, null,
+        React.createElement(Text, { color: "cyan" }, '> '),
+        React.createElement(Text, { color: "whiteBright" },
+            before,
+            React.createElement(Text, { inverse: true }, at),
+            after)))));
+}
+function Message({ role, content, isStreaming, }) {
+    const renderedContent = role === 'assistant' && !isStreaming ? formatMarkdown(content) : content;
+    return (React.createElement(Box, { marginBottom: 1 },
+        React.createElement(Text, null,
+            role === 'user' ? (React.createElement(Text, { color: "cyan", bold: true },
+                "You:",
+                ' ')) : (React.createElement(Text, { color: "green", bold: true },
+                "orch:",
+                ' ')),
+            React.createElement(Text, null, renderedContent))));
+}
+function formatDuration(durationMs) {
+    return `${(durationMs / 1000).toFixed(1)}s`;
+}
+export default function Index() {
+    const { exit } = useApp();
+    const activeRequestControllerRef = useRef(null);
+    const messageCountRef = useRef(0);
+    const [input, setInput] = useState('');
+    const [cursor, setCursor] = useState(0);
+    const [history, setHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const [savedInput, setSavedInput] = useState('');
+    const [messages, setMessages] = useState([]);
+    const [config, setConfig] = useState(null);
+    const [isBusy, setIsBusy] = useState(false);
+    const [showSpinner, setShowSpinner] = useState(false);
+    const [lastResponseMs, setLastResponseMs] = useState();
+    const [lastResponseCost, setLastResponseCost] = useState();
+    const workerCount = config ? Object.keys(config.workers).length : 0;
+    const statusText = lastResponseMs === undefined ||
+        lastResponseCost === undefined ||
+        workerCount === 0
+        ? undefined
+        : `${workerCount} workers · ${formatDuration(lastResponseMs)} · ${lastResponseCost}`;
+    useEffect(() => {
+        let isMounted = true;
+        const initializeConfig = async () => {
+            try {
+                const loadedConfig = await loadConfig();
+                if (isMounted) {
+                    setConfig(loadedConfig);
+                }
+            }
+            catch { }
+        };
+        void initializeConfig();
+        return () => {
+            isMounted = false;
+        };
+    }, []);
+    const createMessageId = () => `message-${messageCountRef.current++}`;
+    const appendAssistantMessage = (messageId, content, isStreaming) => {
+        setMessages(previousMessages => [
+            ...previousMessages,
+            {
+                id: messageId,
+                role: 'assistant',
+                content,
+                isStreaming,
+            },
+        ]);
+    };
+    const updateMessage = (messageId, updater) => {
+        setMessages(previousMessages => previousMessages.map(message => message.id === messageId ? updater(message) : message));
+    };
+    const submitMessage = async (prompt) => {
+        const requestController = new AbortController();
+        const requestStartedAt = Date.now();
+        const userMessageId = createMessageId();
+        let activeConfig = config ?? undefined;
+        let assistantMessageId;
+        let streamedResponse = '';
+        activeRequestControllerRef.current = requestController;
+        setMessages(previousMessages => [
+            ...previousMessages,
+            {
+                id: userMessageId,
+                role: 'user',
+                content: prompt,
+                isStreaming: false,
+            },
+        ]);
+        setHistory(previousHistory => [...previousHistory, prompt]);
+        setHistoryIndex(-1);
+        setSavedInput('');
+        setInput('');
+        setCursor(0);
+        setIsBusy(true);
+        setShowSpinner(true);
+        try {
+            activeConfig = config ?? (await loadConfig());
+            setConfig(activeConfig);
+            const stream = routeStreaming(prompt, activeConfig, {
+                signal: requestController.signal,
+            });
+            let step = await stream.next();
+            while (true) {
+                if (step.done) {
+                    break;
+                }
+                const chunk = step.value.chunk;
+                streamedResponse += chunk;
+                if (assistantMessageId === undefined) {
+                    assistantMessageId = createMessageId();
+                    appendAssistantMessage(assistantMessageId, streamedResponse, true);
+                }
+                else {
+                    updateMessage(assistantMessageId, message => ({
+                        ...message,
+                        content: message.content + chunk,
+                        isStreaming: true,
+                    }));
+                }
+                setShowSpinner(false);
+                step = await stream.next();
+            }
+            const result = step.value;
+            if (assistantMessageId === undefined) {
+                appendAssistantMessage(createMessageId(), result.response, false);
+            }
+            else {
+                updateMessage(assistantMessageId, message => ({
+                    ...message,
+                    content: result.response,
+                    isStreaming: false,
+                }));
+            }
+            updateLastResponseMeta(activeConfig, result.handledBy, Date.now() - requestStartedAt, setLastResponseCost, setLastResponseMs);
+        }
+        catch {
+            if (requestController.signal.aborted) {
+                if (assistantMessageId !== undefined) {
+                    updateMessage(assistantMessageId, message => ({
+                        ...message,
+                        isStreaming: false,
+                    }));
+                }
+                return;
+            }
+            try {
+                activeConfig = activeConfig ?? (await loadConfig());
+                setConfig(activeConfig);
+                const result = await route(prompt, activeConfig, {
+                    signal: requestController.signal,
+                });
+                if (assistantMessageId === undefined) {
+                    appendAssistantMessage(createMessageId(), result.response, false);
+                }
+                else {
+                    updateMessage(assistantMessageId, message => ({
+                        ...message,
+                        content: result.response,
+                        isStreaming: false,
+                    }));
+                }
+                updateLastResponseMeta(activeConfig, result.handledBy, Date.now() - requestStartedAt, setLastResponseCost, setLastResponseMs);
+            }
+            catch {
+                if (!requestController.signal.aborted) {
+                    appendAssistantMessage(createMessageId(), "Sorry, I couldn't handle that. Try again.", false);
+                }
+            }
+        }
+        finally {
+            if (activeRequestControllerRef.current === requestController) {
+                activeRequestControllerRef.current = null;
+            }
+            setIsBusy(false);
+            setShowSpinner(false);
+        }
+    };
+    useInput((ch, key) => {
+        if (key.ctrl && ch === 'c') {
+            if (isBusy) {
+                activeRequestControllerRef.current?.abort(new Error('Request aborted.'));
+                return;
+            }
+            exit();
+            return;
+        }
+        if (isBusy) {
+            return;
+        }
+        if (key.return) {
+            const trimmed = input.trim();
+            if (trimmed === '') {
+                return;
+            }
+            if (trimmed === 'exit' || trimmed === 'quit') {
+                exit();
+                return;
+            }
+            void submitMessage(trimmed);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (cursor > 0) {
+                setInput(previousInput => previousInput.slice(0, cursor - 1) + previousInput.slice(cursor));
+                setCursor(previousCursor => previousCursor - 1);
+            }
+            return;
+        }
+        if (key.leftArrow) {
+            setCursor(previousCursor => Math.max(0, previousCursor - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            setCursor(previousCursor => Math.min(input.length, previousCursor + 1));
+            return;
+        }
+        if (key.upArrow) {
+            if (history.length === 0) {
+                return;
+            }
+            if (historyIndex === -1) {
+                const nextIndex = history.length - 1;
+                const nextInput = history[nextIndex];
+                if (nextInput === undefined) {
+                    return;
+                }
+                setSavedInput(input);
+                setHistoryIndex(nextIndex);
+                setInput(nextInput);
+                setCursor(nextInput.length);
+                return;
+            }
+            const nextIndex = Math.max(0, historyIndex - 1);
+            const nextInput = history[nextIndex];
+            if (nextInput === undefined) {
+                return;
+            }
+            setHistoryIndex(nextIndex);
+            setInput(nextInput);
+            setCursor(nextInput.length);
+            return;
+        }
+        if (key.downArrow) {
+            if (historyIndex === -1) {
+                return;
+            }
+            const nextIndex = historyIndex + 1;
+            if (nextIndex >= history.length) {
+                setHistoryIndex(-1);
+                setInput(savedInput);
+                setCursor(savedInput.length);
+                return;
+            }
+            const nextInput = history[nextIndex];
+            if (nextInput === undefined) {
+                return;
+            }
+            setHistoryIndex(nextIndex);
+            setInput(nextInput);
+            setCursor(nextInput.length);
+            return;
+        }
+        if (ch && !key.ctrl && !key.meta) {
+            setInput(previousInput => previousInput.slice(0, cursor) + ch + previousInput.slice(cursor));
+            setCursor(previousCursor => previousCursor + 1);
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+            React.createElement(Text, null,
+                React.createElement(Text, { color: "cyan", bold: true }, '  orch')),
+            React.createElement(Text, { dimColor: true }, `  ${process.cwd()}`),
+            React.createElement(Text, { dimColor: true }, '  Ctrl+C to exit')),
+        messages.map(message => (React.createElement(Message, { key: message.id, role: message.role, content: message.content, isStreaming: message.isStreaming }))),
+        showSpinner ? (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "cyan" },
+                React.createElement(Spinner, null)),
+            React.createElement(Text, { dimColor: true }, " thinking..."))) : null,
+        React.createElement(Prompt, { value: input, cursor: cursor }),
+        statusText === undefined ? null : (React.createElement(Box, { justifyContent: "flex-end", width: "100%" },
+            React.createElement(Text, { dimColor: true }, statusText)))));
+}
+function updateLastResponseMeta(config, handledBy, responseMs, setLastResponseCost, setLastResponseMs) {
+    const workerCost = config.workers[handledBy]?.cost;
+    if (workerCost === undefined) {
+        return;
+    }
+    setLastResponseCost(workerCost);
+    setLastResponseMs(responseMs);
+}

package/dist/core/config.d.ts

@@ -0,0 +1,5 @@
+import type { OrchConfig } from '../types/index.js';
+export declare const DEFAULT_ESCALATION_PROMPT = "You are orch. Respond to the user's request directly.\nIf you can handle this well, respond normally.\nIf this requires code editing or file modifications, respond with exactly: [ESCALATE:codex]\nIf this requires complex multi-step planning or architecture, respond with exactly: [ESCALATE:claude]\nDo not explain the escalation. Just output the tag.";
+export declare const DEFAULT_CONFIG_PATH: string;
+export declare const DEFAULT_CONFIG: OrchConfig;
+export declare function loadConfig(configPath?: string): Promise<OrchConfig>;

package/dist/core/config.js

@@ -0,0 +1,177 @@
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { parse } from 'yaml';
+const DEFAULT_PRIORITY = ['gemini', 'codex', 'claude'];
+export const DEFAULT_ESCALATION_PROMPT = `You are orch. Respond to the user's request directly.
+If you can handle this well, respond normally.
+If this requires code editing or file modifications, respond with exactly: [ESCALATE:codex]
+If this requires complex multi-step planning or architecture, respond with exactly: [ESCALATE:claude]
+Do not explain the escalation. Just output the tag.`;
+const DEFAULT_WORKERS = {
+    gemini: {
+        command: 'gemini',
+        flags: [],
+        promptFlag: '-p',
+        cost: 'free',
+        description: 'Large context, good for exploration and trivial tasks',
+    },
+    codex: {
+        command: 'codex',
+        flags: ['exec', '--full-auto'],
+        cost: 'low',
+        description: 'Good at code generation, refactoring, debugging',
+    },
+    claude: {
+        command: 'claude',
+        flags: ['--print'],
+        promptFlag: '-p',
+        cost: 'high',
+        description: 'Best reasoning, complex planning, architecture',
+    },
+};
+export const DEFAULT_CONFIG_PATH = join(homedir(), '.orch', 'config.yaml');
+export const DEFAULT_CONFIG = {
+    priority: [...DEFAULT_PRIORITY],
+    workers: cloneWorkers(DEFAULT_WORKERS),
+    escalationPrompt: DEFAULT_ESCALATION_PROMPT,
+};
+export async function loadConfig(configPath = DEFAULT_CONFIG_PATH) {
+    try {
+        const rawConfig = await readFile(configPath, 'utf8');
+        const parsedConfig = parseYamlObject(rawConfig);
+        const config = buildConfig(parsedConfig);
+        validatePriority(config.priority, config.workers);
+        return config;
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return createDefaultConfig();
+        }
+        throw error;
+    }
+}
+function buildConfig(rawConfig) {
+    return {
+        priority: parsePriority(rawConfig['priority']),
+        workers: parseWorkers(rawConfig['workers']),
+        escalationPrompt: parseEscalationPrompt(rawConfig['escalationPrompt'] ?? rawConfig['escalation_prompt']),
+    };
+}
+function parseYamlObject(rawConfig) {
+    const parsed = parse(rawConfig);
+    if (parsed === null) {
+        return {};
+    }
+    if (!isRecord(parsed)) {
+        throw new TypeError('Config file must contain a YAML object.');
+    }
+    return parsed;
+}
+function parsePriority(rawPriority) {
+    if (rawPriority === undefined) {
+        return [...DEFAULT_PRIORITY];
+    }
+    const priority = parseStringArray(rawPriority, 'priority');
+    if (priority.length === 0) {
+        throw new TypeError('Config priority must contain at least one worker.');
+    }
+    return priority;
+}
+function parseWorkers(rawWorkers) {
+    if (rawWorkers === undefined) {
+        return cloneWorkers(DEFAULT_WORKERS);
+    }
+    if (!isRecord(rawWorkers)) {
+        throw new TypeError('Config workers must be an object.');
+    }
+    const workers = cloneWorkers(DEFAULT_WORKERS);
+    for (const [workerName, rawWorker] of Object.entries(rawWorkers)) {
+        if (!isRecord(rawWorker)) {
+            throw new TypeError(`Config worker "${workerName}" must be an object.`);
+        }
+        const defaultWorker = DEFAULT_WORKERS[workerName];
+        workers[workerName] = {
+            command: parseRequiredString(rawWorker['command'], `${workerName}.command`, defaultWorker?.command),
+            flags: parseStringArray(rawWorker['flags'] ?? defaultWorker?.flags ?? [], `${workerName}.flags`),
+            promptFlag: parseOptionalString(rawWorker['promptFlag'] ?? rawWorker['prompt_flag'], defaultWorker?.promptFlag),
+            cost: parseWorkerCost(rawWorker['cost'], `${workerName}.cost`, defaultWorker?.cost),
+            description: parseRequiredString(rawWorker['description'], `${workerName}.description`, defaultWorker?.description),
+        };
+    }
+    return workers;
+}
+function parseEscalationPrompt(rawPrompt) {
+    return parseRequiredString(rawPrompt, 'escalation_prompt', DEFAULT_ESCALATION_PROMPT);
+}
+function parseOptionalString(value, defaultValue) {
+    if (value === undefined || value === null) {
+        return defaultValue;
+    }
+    if (typeof value === 'string' && value.trim() !== '') {
+        return value;
+    }
+    return defaultValue;
+}
+function parseRequiredString(value, fieldName, defaultValue) {
+    if (value === undefined) {
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        throw new TypeError(`Config field "${fieldName}" is required.`);
+    }
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new TypeError(`Config field "${fieldName}" must be a non-empty string.`);
+    }
+    return value;
+}
+function parseStringArray(value, fieldName) {
+    if (!Array.isArray(value)) {
+        throw new TypeError(`Config field "${fieldName}" must be an array of strings.`);
+    }
+    return value.map((item, index) => {
+        if (typeof item !== 'string' || item.trim() === '') {
+            throw new TypeError(`Config field "${fieldName}[${index}]" must be a non-empty string.`);
+        }
+        return item;
+    });
+}
+function parseWorkerCost(value, fieldName, defaultValue) {
+    const cost = parseRequiredString(value, fieldName, defaultValue);
+    if (cost !== 'free' && cost !== 'low' && cost !== 'high') {
+        throw new TypeError(`Config field "${fieldName}" must be one of: free, low, high.`);
+    }
+    return cost;
+}
+function validatePriority(priority, workers) {
+    for (const workerName of priority) {
+        if (!(workerName in workers)) {
+            throw new TypeError(`Config priority references unknown worker "${workerName}".`);
+        }
+    }
+}
+function createDefaultConfig() {
+    return {
+        priority: [...DEFAULT_CONFIG.priority],
+        workers: cloneWorkers(DEFAULT_CONFIG.workers),
+        escalationPrompt: DEFAULT_CONFIG.escalationPrompt,
+    };
+}
+function cloneWorkers(workers) {
+    return Object.fromEntries(Object.entries(workers).map(([workerName, workerConfig]) => [
+        workerName,
+        {
+            ...workerConfig,
+            flags: [...workerConfig.flags],
+        },
+    ]));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isMissingFileError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}

package/dist/core/markdown.d.ts

@@ -0,0 +1 @@
+export declare function formatMarkdown(text: string): string;

package/dist/core/markdown.js

@@ -0,0 +1,12 @@
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
+const terminalRenderer = new TerminalRenderer();
+export function formatMarkdown(text) {
+    return marked
+        .parse(text, {
+        renderer: terminalRenderer,
+        headerIds: false,
+        mangle: false,
+    })
+        .trimEnd();
+}

package/dist/core/router.d.ts

@@ -0,0 +1,6 @@
+import type { OrchConfig, RouteResult, RouteStreamChunk, SpawnWorkerOptions } from '../types/index.js';
+type RouteOptions = Pick<SpawnWorkerOptions, 'signal'>;
+export declare function loadAndRoute(prompt: string, options?: RouteOptions): Promise<RouteResult>;
+export declare function route(prompt: string, config: OrchConfig, options?: RouteOptions): Promise<RouteResult>;
+export declare function routeStreaming(prompt: string, config: OrchConfig, options?: RouteOptions): AsyncGenerator<RouteStreamChunk, RouteResult>;
+export {};

package/dist/core/router.js

@@ -0,0 +1,220 @@
+import { loadConfig } from './config.js';
+import { spawnWorker, spawnWorkerStreaming } from './spawner.js';
+const escalationPattern = /^\[ESCALATE:([^\]]+)\]$/u;
+const defaultErrorResponse = "Sorry, I couldn't handle that.";
+const escalationPrefix = '[ESCALATE:';
+export async function loadAndRoute(prompt, options = {}) {
+    const config = await loadConfig();
+    return route(prompt, config, options);
+}
+export async function route(prompt, config, options = {}) {
+    const state = {
+        attemptedWorkers: new Set(),
+        escalationChain: [],
+        escalated: false,
+    };
+    const [firstWorkerName, ...fallbackWorkerNames] = config.priority;
+    if (!firstWorkerName) {
+        return createFailureResult(state);
+    }
+    const pendingWorkers = [firstWorkerName, ...fallbackWorkerNames];
+    while (pendingWorkers.length > 0) {
+        throwIfAborted(options.signal);
+        const workerName = pendingWorkers.shift();
+        if (workerName === undefined || state.attemptedWorkers.has(workerName)) {
+            continue;
+        }
+        const workerPrompt = state.attemptedWorkers.size === 0
+            ? `${config.escalationPrompt}\n\n${prompt}`
+            : prompt;
+        const output = await runWorker(config.workers[workerName], workerName, workerPrompt, state, options);
+        state.attemptedWorkers.add(workerName);
+        if (output === undefined) {
+            continue;
+        }
+        const escalationTarget = getEscalationTarget(output);
+        if (escalationTarget === undefined) {
+            return {
+                response: output,
+                handledBy: workerName,
+                escalated: state.escalated,
+                escalationChain: state.escalationChain,
+            };
+        }
+        if (config.workers[escalationTarget] !== undefined &&
+            !state.attemptedWorkers.has(escalationTarget)) {
+            state.escalated = true;
+            pendingWorkers.unshift(escalationTarget);
+        }
+    }
+    return createFailureResult(state);
+}
+export async function* routeStreaming(prompt, config, options = {}) {
+    const state = {
+        attemptedWorkers: new Set(),
+        escalationChain: [],
+        escalated: false,
+    };
+    const [firstWorkerName, ...fallbackWorkerNames] = config.priority;
+    if (!firstWorkerName) {
+        return createFailureResult(state);
+    }
+    const pendingWorkers = [firstWorkerName, ...fallbackWorkerNames];
+    while (pendingWorkers.length > 0) {
+        throwIfAborted(options.signal);
+        const workerName = pendingWorkers.shift();
+        if (workerName === undefined || state.attemptedWorkers.has(workerName)) {
+            continue;
+        }
+        const workerPrompt = state.attemptedWorkers.size === 0
+            ? `${config.escalationPrompt}\n\n${prompt}`
+            : prompt;
+        const result = yield* attemptWorkerStream(config.workers[workerName], workerName, workerPrompt, state, options);
+        state.attemptedWorkers.add(workerName);
+        if (result.type === 'deliver') {
+            return {
+                response: result.output,
+                handledBy: result.handledBy,
+                escalated: state.escalated,
+                escalationChain: state.escalationChain,
+            };
+        }
+        if (result.type === 'escalate' &&
+            config.workers[result.target] !== undefined &&
+            !state.attemptedWorkers.has(result.target)) {
+            state.escalated = true;
+            pendingWorkers.unshift(result.target);
+        }
+    }
+    return createFailureResult(state);
+}
+async function* attemptWorkerStream(worker, workerName, prompt, state, options) {
+    if (worker === undefined) {
+        return { type: 'none' };
+    }
+    state.escalationChain.push(workerName);
+    const streamingWorker = spawnWorkerStreaming(worker.command, worker.flags, prompt, {
+        promptFlag: worker.promptFlag,
+        signal: options.signal,
+    });
+    let bufferedOutput = '';
+    let streamedOutput = '';
+    let isStreaming = false;
+    try {
+        for await (const chunk of streamingWorker.stream) {
+            throwIfAborted(options.signal);
+            if (!isStreaming) {
+                bufferedOutput += chunk;
+                if (canStillBeEscalation(bufferedOutput)) {
+                    continue;
+                }
+                isStreaming = true;
+                streamedOutput = bufferedOutput;
+                yield {
+                    chunk: bufferedOutput,
+                    handledBy: workerName,
+                };
+                bufferedOutput = '';
+                continue;
+            }
+            streamedOutput += chunk;
+            yield {
+                chunk,
+                handledBy: workerName,
+            };
+        }
+        throwIfAborted(options.signal);
+        const completed = await streamingWorker.completed;
+        if (completed.error !== undefined) {
+            return { type: 'none' };
+        }
+        if (isStreaming) {
+            return streamedOutput.trim() === ''
+                ? { type: 'none' }
+                : {
+                    type: 'deliver',
+                    output: streamedOutput,
+                    handledBy: workerName,
+                };
+        }
+        const finalOutput = bufferedOutput.trim() === '' ? completed.output : bufferedOutput;
+        const escalationTarget = getEscalationTarget(finalOutput);
+        if (escalationTarget !== undefined) {
+            return {
+                type: 'escalate',
+                target: escalationTarget,
+            };
+        }
+        if (finalOutput.trim() === '') {
+            return { type: 'none' };
+        }
+        yield {
+            chunk: finalOutput,
+            handledBy: workerName,
+        };
+        return {
+            type: 'deliver',
+            output: finalOutput,
+            handledBy: workerName,
+        };
+    }
+    catch (error) {
+        if (options.signal?.aborted) {
+            streamingWorker.kill();
+            throw error;
+        }
+        return { type: 'none' };
+    }
+}
+function canStillBeEscalation(output) {
+    const trimmedOutput = output.trim();
+    if (trimmedOutput === '') {
+        return true;
+    }
+    if (escalationPrefix.startsWith(trimmedOutput)) {
+        return true;
+    }
+    if (trimmedOutput.startsWith(escalationPrefix) &&
+        !trimmedOutput.includes(']')) {
+        return true;
+    }
+    return escalationPattern.test(trimmedOutput);
+}
+function getEscalationTarget(output) {
+    const match = escalationPattern.exec(output.trim());
+    if (match === null) {
+        return undefined;
+    }
+    const workerName = match[1]?.trim();
+    return workerName === '' ? undefined : workerName;
+}
+function createFailureResult(state) {
+    return {
+        response: defaultErrorResponse,
+        handledBy: '',
+        escalated: state.escalated,
+        escalationChain: state.escalationChain,
+    };
+}
+async function runWorker(worker, workerName, prompt, state, options) {
+    if (worker === undefined) {
+        return undefined;
+    }
+    state.escalationChain.push(workerName);
+    const result = await spawnWorker(worker.command, worker.flags, prompt, {
+        promptFlag: worker.promptFlag,
+        signal: options.signal,
+    });
+    throwIfAborted(options.signal);
+    if (result.error !== undefined || result.output.trim() === '') {
+        return undefined;
+    }
+    return result.output;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw signal.reason instanceof Error
+            ? signal.reason
+            : new Error('Request aborted.');
+    }
+}

package/dist/core/spawner.d.ts

@@ -0,0 +1,3 @@
+import type { SpawnResult, SpawnWorkerOptions, StreamingSpawnResult } from '../types/index.js';
+export declare function spawnWorker(command: string, flags: string[], prompt: string, options?: SpawnWorkerOptions): Promise<SpawnResult>;
+export declare function spawnWorkerStreaming(command: string, flags: string[], prompt: string, options?: SpawnWorkerOptions): StreamingSpawnResult;

package/dist/core/spawner.js

@@ -0,0 +1,164 @@
+import { execa } from 'execa';
+const defaultTimeoutMs = 120000;
+const failedExitCode = 1;
+export async function spawnWorker(command, flags, prompt, options = {}) {
+    const { promptFlag, signal, timeoutMs = defaultTimeoutMs } = options;
+    const args = buildArgs(flags, prompt, promptFlag);
+    const result = await execa(command, args, {
+        reject: false,
+        stderr: 'pipe',
+        stdout: 'pipe',
+        signal,
+        timeout: timeoutMs,
+    });
+    return createSpawnResult({
+        ...result,
+        stdout: result.stdout ?? '',
+    }, command, timeoutMs);
+}
+export function spawnWorkerStreaming(command, flags, prompt, options = {}) {
+    const { promptFlag, signal, timeoutMs = defaultTimeoutMs } = options;
+    const args = buildArgs(flags, prompt, promptFlag);
+    const workerProcess = execa(command, args, {
+        buffer: false,
+        reject: false,
+        stderr: 'pipe',
+        stdout: 'pipe',
+        signal,
+        timeout: timeoutMs,
+    });
+    let output = '';
+    let stderr = '';
+    const stream = createStream(workerProcess.stdout, chunk => {
+        output += chunk;
+    });
+    const stderrDone = consumeStream(workerProcess.stderr, chunk => {
+        stderr += chunk;
+    });
+    const completed = workerProcess
+        .then(async (result) => {
+        await stderrDone;
+        return createSpawnResult({
+            ...result,
+            stderr,
+            stdout: output,
+        }, command, timeoutMs);
+    })
+        .catch(async (error) => {
+        await stderrDone;
+        return createSpawnResult({
+            ...normalizeProcessError(error),
+            stderr,
+            stdout: output,
+        }, command, timeoutMs);
+    });
+    return {
+        stream,
+        kill: () => {
+            if (!workerProcess.killed) {
+                workerProcess.kill();
+            }
+        },
+        exitCode: completed.then(result => result.exitCode),
+        completed,
+        worker: command,
+    };
+}
+function buildArgs(flags, prompt, promptFlag) {
+    return promptFlag ? [...flags, promptFlag, prompt] : [...flags, prompt];
+}
+function createStream(stream, onChunk) {
+    return {
+        async *[Symbol.asyncIterator]() {
+            if (stream === undefined || stream === null) {
+                return;
+            }
+            for await (const chunk of stream) {
+                const text = toTextChunk(chunk);
+                if (text === '') {
+                    continue;
+                }
+                onChunk(text);
+                yield text;
+            }
+        },
+    };
+}
+async function consumeStream(stream, onChunk) {
+    if (stream === undefined || stream === null) {
+        return;
+    }
+    try {
+        for await (const chunk of stream) {
+            const text = toTextChunk(chunk);
+            if (text !== '') {
+                onChunk(text);
+            }
+        }
+    }
+    catch { }
+}
+function toTextChunk(chunk) {
+    if (typeof chunk === 'string') {
+        return chunk;
+    }
+    if (chunk instanceof Uint8Array) {
+        return Buffer.from(chunk).toString('utf8');
+    }
+    return String(chunk);
+}
+function createSpawnResult(result, command, timeoutMs) {
+    const error = getErrorMessage(result, timeoutMs);
+    return {
+        output: result.stdout ?? '',
+        exitCode: result.exitCode ?? failedExitCode,
+        worker: command,
+        ...(error === undefined ? {} : { error }),
+    };
+}
+function normalizeProcessError(error) {
+    if (typeof error !== 'object' || error === null) {
+        return {
+            failed: true,
+            timedOut: false,
+            message: 'Worker process failed.',
+        };
+    }
+    return {
+        exitCode: 'exitCode' in error && typeof error.exitCode === 'number'
+            ? error.exitCode
+            : undefined,
+        failed: true,
+        message: 'message' in error && typeof error.message === 'string'
+            ? error.message
+            : 'Worker process failed.',
+        shortMessage: 'shortMessage' in error && typeof error.shortMessage === 'string'
+            ? error.shortMessage
+            : undefined,
+        stderr: 'stderr' in error && typeof error.stderr === 'string'
+            ? error.stderr
+            : undefined,
+        stdout: 'stdout' in error && typeof error.stdout === 'string'
+            ? error.stdout
+            : undefined,
+        timedOut: 'timedOut' in error && typeof error.timedOut === 'boolean'
+            ? error.timedOut
+            : false,
+    };
+}
+function getErrorMessage(result, timeoutMs) {
+    const stderr = result.stderr?.trim();
+    if (result.timedOut) {
+        return stderr
+            ? `Worker timed out after ${timeoutMs}ms.\n${stderr}`
+            : `Worker timed out after ${timeoutMs}ms.`;
+    }
+    if (result.failed) {
+        return stderr
+            ? stderr
+            : result.shortMessage ?? result.message ?? 'Worker process failed.';
+    }
+    // Only treat stderr as error when process actually failed.
+    // Many CLIs (e.g. gemini) write debug/info logs to stderr on success.
+    return undefined;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,41 @@
+export type WorkerCost = 'free' | 'low' | 'high';
+export interface WorkerConfig {
+    command: string;
+    flags: string[];
+    promptFlag?: string;
+    cost: WorkerCost;
+    description: string;
+}
+export interface OrchConfig {
+    priority: string[];
+    workers: Record<string, WorkerConfig>;
+    escalationPrompt: string;
+}
+export interface SpawnResult {
+    output: string;
+    exitCode: number;
+    error?: string;
+    worker: string;
+}
+export interface SpawnWorkerOptions {
+    promptFlag?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface StreamingSpawnResult {
+    stream: AsyncIterable<string>;
+    kill: () => void;
+    exitCode: Promise<number>;
+    completed: Promise<SpawnResult>;
+    worker: string;
+}
+export interface RouteResult {
+    response: string;
+    handledBy: string;
+    escalated: boolean;
+    escalationChain: string[];
+}
+export interface RouteStreamChunk {
+    chunk: string;
+    handledBy: string;
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,81 @@
+{
+	"name": "@waqas/orch",
+	"version": "0.1.0",
+	"description": "An AI CLI that routes prompts across external AI CLIs and feels like one assistant.",
+	"license": "MIT",
+	"bin": {
+		"orch": "dist/cli.js"
+	},
+	"type": "module",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/waqaskhan137/orch.git"
+	},
+	"homepage": "https://github.com/waqaskhan137/orch",
+	"bugs": {
+		"url": "https://github.com/waqaskhan137/orch/issues"
+	},
+	"publishConfig": {
+		"access": "public",
+		"registry": "https://registry.npmjs.org/"
+	},
+	"engines": {
+		"node": ">=16"
+	},
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch",
+		"release:check": "node ./scripts/release.mjs check",
+		"release:patch": "node ./scripts/release.mjs patch",
+		"release:minor": "node ./scripts/release.mjs minor",
+		"release:major": "node ./scripts/release.mjs major",
+		"test": "prettier --check . && xo && ava"
+	},
+	"files": [
+		"dist"
+	],
+	"dependencies": {
+		"execa": "^8.0.1",
+		"ink": "^4.1.0",
+		"ink-spinner": "^5.0.0",
+		"marked": "^5.1.2",
+		"marked-terminal": "^5.2.0",
+		"pastel": "^2.0.0",
+		"react": "^18.2.0",
+		"yaml": "^2.8.3",
+		"zod": "^3.21.4"
+	},
+	"devDependencies": {
+		"@sindresorhus/tsconfig": "^3.0.1",
+		"@types/marked": "^5.0.2",
+		"@types/react": "^18.0.32",
+		"@vdemedes/prettier-config": "^2.0.1",
+		"ava": "^5.2.0",
+		"chalk": "^5.2.0",
+		"eslint-config-xo-react": "^0.27.0",
+		"eslint-plugin-react": "^7.32.2",
+		"eslint-plugin-react-hooks": "^4.6.0",
+		"ink-testing-library": "^3.0.0",
+		"prettier": "^2.8.7",
+		"ts-node": "^10.9.1",
+		"typescript": "^5.0.3",
+		"xo": "^0.54.2"
+	},
+	"ava": {
+		"extensions": {
+			"ts": "module",
+			"tsx": "module"
+		},
+		"nodeArguments": [
+			"--loader=ts-node/esm"
+		]
+	},
+	"xo": {
+		"extends": "xo-react",
+		"prettier": true,
+		"rules": {
+			"react/prop-types": "off"
+		}
+	},
+	"prettier": "@vdemedes/prettier-config"
+}

package/readme.md

@@ -0,0 +1,17 @@
+# orch
+
+`orch` is an AI CLI that routes prompts across external AI CLIs and feels like one assistant.
+
+## Install
+
+```bash
+npm install --global @waqas/orch
+```
+
+## Usage
+
+```bash
+orch
+```
+
+The installed command is still `orch`.