@orbit-intelligence/orbit-agent 0.3.12

package/dist/src/cli/run.js

@@ -0,0 +1,393 @@
+import { resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { parseArgs, HELP } from './args.js';
+import { VERSION } from '../version.js';
+import { touchConfig, saveConfig } from '../config/index.js';
+import { EventBus } from '../core/events.js';
+import { buildProviders, resolveCandidates } from '../core/llm/index.js';
+import { AutoRouter } from '../core/llm/router.js';
+import { ContextManager } from '../core/context/context-manager.js';
+import { ToolRegistry } from '../core/tools/registry.js';
+import { PermissionManager } from '../core/permissions/index.js';
+import { Orchestrator } from '../core/agents/orchestrator.js';
+import { buildSystemPrompt } from '../../prompts/system.js';
+import { TuiApp } from '../tui/app.js';
+import { hasAnySecrets } from '../core/llm/secrets.js';
+import { runWizard } from '../setup/wizard.js';
+import { createSession, saveSession, pruneSessions } from '../session/store.js';
+import { createEventLog, appendEvent, readEventLog } from '../session/event-log.js';
+import { loadProjectContext } from '../core/project-context.js';
+import { createSkillLoaderTool } from '../core/skill-loader.js';
+const THEME_NAMES = ['tokyonight', 'catppuccin-mocha', 'catppuccin-latte', 'nord', 'gruvbox', 'monokai', 'clean-dark'];
+const PROVIDER_IDS = ['orbitx', 'groq', 'gemini', 'openrouter', 'openai'];
+export async function main(argv) {
+    let args;
+    try {
+        args = parseArgs(argv);
+    }
+    catch (err) {
+        console.error(err.message);
+        console.error(HELP);
+        return 1;
+    }
+    if (args.help) {
+        console.log(HELP);
+        return 0;
+    }
+    if (args.version) {
+        console.log(`orbit ${VERSION}`);
+        return 0;
+    }
+    // `orbit log <id>` — print a session's append-only event log.
+    if (args.log) {
+        const entries = readEventLog(args.log);
+        if (entries.length === 0) {
+            console.error(`No event log for session "${args.log}".`);
+            return 1;
+        }
+        for (const e of entries) {
+            const d = e.data;
+            const when = new Date(e.ts).toISOString();
+            switch (e.type) {
+                case 'user':
+                    console.log(`\x1b[2m${when}\x1b[0m \x1b[36muser\x1b[0m`);
+                    console.log(`  ${d?.text ?? ''}`);
+                    break;
+                case 'tool':
+                    console.log(`\x1b[2m${when}\x1b[0m \x1b[33mtool\x1b[0m ${d?.name ?? '?'} → ${String(d?.status ?? '')} (${String(d?.durationMs ?? '')}ms)`);
+                    break;
+                case 'diff': {
+                    const path = d?.path;
+                    console.log(`\x1b[2m${when}\x1b[0m \x1b[32mdiff\x1b[0m ${path} +${d?.added} −${d?.removed}`);
+                    break;
+                }
+                case 'plan_proposed':
+                    console.log(`\x1b[2m${when}\x1b[0m \x1b[35mplan\x1b[0m proposed for "${d?.task}"`);
+                    break;
+                case 'plan_approved':
+                    console.log(`\x1b[2m${when}\x1b[0m \x1b[35mplan\x1b[0m approved for "${d?.task}"`);
+                    break;
+                case 'plan_rejected':
+                    console.log(`\x1b[2m${when}\x1b[0m \x1b[35mplan\x1b[0m rejected for "${d?.task}"`);
+                    break;
+                default:
+                    console.log(`\x1b[2m${when}\x1b[0m \x1b[31m${e.type}\x1b[0m ${d?.message ?? JSON.stringify(d ?? {})}`);
+            }
+        }
+        return 0;
+    }
+    const cwd = resolve(args.cwd ?? process.cwd());
+    let cfg = touchConfig();
+    // CLI overrides
+    if (args.theme) {
+        const t = args.theme.toLowerCase().replace(/[ _]/g, '-');
+        if (THEME_NAMES.includes(t))
+            cfg.theme = t;
+    }
+    if (args.provider) {
+        const p = args.provider.toLowerCase();
+        if (PROVIDER_IDS.includes(p))
+            cfg.provider = p;
+    }
+    if (args.model) {
+        cfg.model.fallback = [cfg.model.primary, ...cfg.model.fallback].filter((m, i, arr) => m !== args.model && arr.indexOf(m) === i);
+        cfg.model.primary = args.model;
+    }
+    if (args.yolo)
+        cfg.permissions.mode = 'allow';
+    if (args.yes && !args.yolo)
+        cfg.permissions.mode = 'allow';
+    // Single-shot mode: no TTY required, prints the answer and exits.
+    const singleShot = Boolean(args.run || args.prompt);
+    if (singleShot) {
+        const prompt = args.prompt?.trim() || 'Summarize this project and recommend the next task.';
+        if (args.setup) {
+            const next = await runWizard(cfg, args);
+            if (!next)
+                return 130;
+            cfg = next;
+            saveConfig(cfg);
+        }
+        return await runSingleShot(cfg, cwd, prompt, args.yes || args.yolo);
+    }
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+        console.error('orbit requires an interactive TTY for the TUI. Use `orbit run "<prompt>"` for a headless single-shot turn.');
+        return 1;
+    }
+    // First-run wizard
+    if (!cfg.firstRunComplete || args.setup) {
+        const next = await runWizard(cfg, args);
+        if (!next)
+            return 130; // aborted
+        cfg = next;
+        saveConfig(cfg);
+    }
+    // Build runtime
+    const bus = new EventBus();
+    let providers = buildProviders(cfg);
+    let router = await makeRouter(cfg, providers);
+    if (router.candidateList.length === 0) {
+        const hasKeys = hasAnySecrets();
+        const tip = hasKeys
+            ? 'Provider keys are present — run `orbit setup` to pick a provider/model.'
+            : 'No LLM provider is configured. Run `orbit setup`, set an Orbit X URL/token, or provider keys in environment variables.';
+        console.error(`⚠  No models available for routing.\n    ${tip}\n`);
+        return 1;
+    }
+    // Project context: AGENTS.md conventions + .orbit/skills. Injected into the
+    // system prompt; skills exposed both to the model (load_project_skill) and
+    // the /skills command.
+    const project = loadProjectContext(cwd);
+    const systemPrompt = buildSystemPrompt(cfg, cwd, {
+        conventions: project.conventions,
+        skills: project.skills.map((s) => ({ name: s.name, summary: s.summary })),
+    });
+    if (args.orchestrate) {
+        const { runOrchestrateCmd } = await import('./orchestrate.js');
+        return runOrchestrateCmd({
+            config: cfg,
+            providers,
+            bus,
+            cwd,
+            maxTokensPerSecond: Math.max(0, cfg.ui.maxTokensPerSecond),
+        });
+    }
+    const context = new ContextManager(systemPrompt);
+    const registry = new ToolRegistry({ cwd, canWrite: true, shell: cfg.tools.shell });
+    let session = createSession(new Date().toLocaleString(), cwd);
+    if (args.session) {
+        const { loadSession } = await import('../session/store.js');
+        const prior = loadSession(args.session);
+        if (prior) {
+            // Resume: reuse the prior session id + history so the story continues.
+            for (const m of prior.messages)
+                context.add(m);
+            session = { ...prior, updatedAt: Date.now() };
+            console.log(`\x1b[2mResumed session ${prior.id} (${prior.messages.length} messages).\x1b[0m`);
+        }
+        else {
+            console.error(`No session "${args.session}" found. Run orbit log to find one.`);
+            return 1;
+        }
+    }
+    createEventLog(session.id);
+    registry.register(createSkillLoaderTool(project));
+    const permissions = new PermissionManager(cfg.permissions, {
+        ask: (prompt) => app.ask(prompt),
+    });
+    let agent = makeAgent(cfg, router, bus, context, registry, permissions, systemPrompt, cwd);
+    function rebuild() {
+        return rebuildPipeline(cfg, bus).then((next) => {
+            providers = next.providers;
+            router = next.router;
+            agent = makeAgent(cfg, router, bus, context, registry, permissions, systemPrompt, cwd);
+            emitRoute(bus, router, cfg);
+            saveConfig(cfg);
+        });
+    }
+    const onCommand = async (cmd) => {
+        switch (cmd.type) {
+            case 'model': {
+                if (!cmd.value)
+                    return null;
+                cfg.model.fallback = [cfg.model.primary, ...cfg.model.fallback].filter((m, i, arr) => m !== cmd.value && arr.indexOf(m) === i);
+                cfg.model.primary = cmd.value;
+                await rebuild();
+                return `Model → ${cfg.model.primary}`;
+            }
+            case 'provider': {
+                cfg.provider = cmd.value;
+                await rebuild();
+                return `Provider → ${cfg.provider}`;
+            }
+            case 'theme':
+                saveConfig(cfg);
+                return null;
+            case 'yolo':
+                cfg.permissions.mode = 'allow';
+                saveConfig(cfg);
+                return null;
+            default:
+                return null;
+        }
+    };
+    // Abort the in-flight run when the user hits Escape / Ctrl-C while streaming.
+    bus.on('onAbortRequest', () => agent.abort());
+    // Audit trail: record the interesting stream into the session event log.
+    bus.on('onToolEnd', (call) => {
+        appendEvent(session.id, {
+            level: 'tool',
+            type: 'tool',
+            data: { name: call.name, status: call.status, durationMs: call.durationMs, argsPreview: call.args.slice(0, 200) },
+        });
+    });
+    bus.on('onFileDiff', (d) => {
+        appendEvent(session.id, { level: 'tool', type: 'diff', data: { path: d.path, added: d.added, removed: d.removed } });
+    });
+    bus.on('onPlanProposed', (plan) => {
+        appendEvent(session.id, { level: 'plan', type: 'plan_proposed', data: { task: plan.task, text: plan.text } });
+    });
+    bus.on('onPlanApproved', (task) => {
+        appendEvent(session.id, { level: 'plan', type: 'plan_approved', data: { task } });
+    });
+    bus.on('onPlanRejected', (task) => {
+        appendEvent(session.id, { level: 'plan', type: 'plan_rejected', data: { task } });
+    });
+    bus.on('onError', (err) => {
+        appendEvent(session.id, { level: 'error', type: 'error', data: { message: err.message } });
+    });
+    const app = new TuiApp({
+        config: cfg,
+        bus,
+        onSubmit: (text) => submitQueued(text),
+        onCommand,
+        version: VERSION,
+        models: router.order(),
+    });
+    app.store.skills = project.skills.map((s) => ({ name: s.name, summary: s.summary }));
+    const resumeMessages = session.messages.filter((m) => m.role !== 'tool');
+    if (resumeMessages.length > 0)
+        app.store.messages = resumeMessages;
+    function makeAgent(config, r, evBus, ctx, reg, perms, sys, wd) {
+        return new Orchestrator({
+            bus: evBus,
+            router: r,
+            permissions: perms,
+            systemPrompt: sys,
+            context: ctx,
+            registry: reg,
+            cwd: wd,
+            config,
+            maxTokensPerSecond: Math.max(0, config.ui.maxTokensPerSecond),
+        });
+    }
+    // Serialized submission queue
+    let processing = false;
+    const queue = [];
+    async function submitQueued(text) {
+        queue.push(text);
+        await drain();
+    }
+    async function drain() {
+        if (processing)
+            return;
+        processing = true;
+        while (queue.length > 0) {
+            const text = queue.shift();
+            appendEvent(session.id, { level: 'info', type: 'user', data: { text } });
+            try {
+                await agent.run(text);
+            }
+            catch (err) {
+                appendEvent(session.id, { level: 'error', type: 'error', data: { message: err.message } });
+                bus.emit('onError', err);
+            }
+            session.messages = context.history();
+            saveSession(session);
+            pruneSessions(50);
+        }
+        processing = false;
+    }
+    // Greet with route info once
+    emitRoute(bus, router, cfg);
+    app.run();
+    // Keep process alive; clean exit signals
+    return await new Promise((r) => {
+        process.once('SIGINT', () => {
+            app.destroy();
+            r(130);
+        });
+        process.once('SIGTERM', () => {
+            app.destroy();
+            r(143);
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// Single-shot mode
+// ---------------------------------------------------------------------------
+async function runSingleShot(cfg, cwd, prompt, autoAllow) {
+    const bus = new EventBus();
+    // `orbit run` is pinned to Orbit X — the gateway's own service env holds the
+    // upstream keys (Groq/Gemini/OpenRouter), so no local token is needed unless
+    // the gateway enforces one (ORBITX_TOKEN set server-side).
+    const runCfg = { ...cfg, provider: 'orbitx' };
+    const providers = buildProviders(runCfg);
+    if (!providers.orbitx) {
+        console.error('⚠  Could not initialise the Orbit X client.');
+        return 1;
+    }
+    const router = await makeRouter(runCfg, providers);
+    const project = loadProjectContext(cwd);
+    const systemPrompt = buildSystemPrompt(cfg, cwd, {
+        conventions: project.conventions,
+        skills: project.skills.map((s) => ({ name: s.name, summary: s.summary })),
+    });
+    const context = new ContextManager(systemPrompt);
+    const registry = new ToolRegistry({ cwd, canWrite: true, shell: cfg.tools.shell });
+    registry.register(createSkillLoaderTool(project));
+    const permissionMode = autoAllow ? 'allow' : cfg.permissions.mode;
+    const permissions = new PermissionManager({ ...cfg.permissions, mode: permissionMode }, { ask: (q) => askConsole(q) });
+    bus.on('onAbortRequest', () => agent.abort());
+    const agent = new Orchestrator({
+        bus,
+        router,
+        permissions,
+        systemPrompt,
+        context,
+        registry,
+        cwd,
+        config: cfg,
+        maxTokensPerSecond: 0,
+    });
+    let output = '';
+    let errored = false;
+    bus.on('onAssistantStart', (msg) => { output = msg.content; });
+    bus.on('onToken', (text) => { output += text; });
+    bus.on('onAssistantEnd', (msg) => { if (msg.content)
+        output = msg.content; });
+    bus.on('onThinking', () => { });
+    bus.on('onError', (err) => { errored = true; console.error(`\n⚠ ${err.message}`); });
+    bus.on('onRoute', (s) => { console.error(`${s.provider}/${s.model} (${s.strategy})`); });
+    const res = await agent.run(prompt);
+    const trimmed = output.trim();
+    if (trimmed)
+        process.stdout.write(trimmed.endsWith('\n') ? trimmed : `${trimmed}\n`);
+    else if (!errored) {
+        console.error('⚠ The model returned no content. Try again, or switch models with `/model <id>`.');
+    }
+    if (res.interrupted || res.error)
+        return 1;
+    if (!trimmed)
+        return 1;
+    return res.turns > 0 ? 0 : 1;
+}
+function askConsole(prompt) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        process.stderr.write(`⚠ ${prompt} (y/N) `);
+        rl.once('line', (line) => {
+            rl.close();
+            const ok = /^(y|yes|true|allow|sure)$/i.test(line.trim());
+            resolve(ok);
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// Pipeline builders
+// ---------------------------------------------------------------------------
+async function makeRouter(cfg, providers) {
+    const candidates = await resolveCandidates(cfg, providers);
+    return new AutoRouter(providers, candidates, cfg.routing.strategy);
+}
+async function rebuildPipeline(cfg, bus) {
+    const providers = buildProviders(cfg);
+    const router = await makeRouter(cfg, providers);
+    return { providers, router };
+}
+function emitRoute(bus, router, cfg) {
+    const firstRoute = router.peek();
+    if (firstRoute) {
+        bus.emit('onRoute', { ...firstRoute, strategy: cfg.routing.strategy });
+    }
+}

package/dist/src/config/config-schema.js

@@ -0,0 +1,151 @@
+import { z } from 'zod';
+/**
+ * Config schema for orbit-agent.
+ * Provider keys are NEVER stored here — they live in env vars or the
+ * git-ignored keys.json (0600 perms). Read via core/llm/secrets.ts.
+ */
+export const providerNames = ['orbitx', 'groq', 'gemini', 'openrouter', 'openai'];
+export const effortLevels = ['none', 'minimal', 'low', 'medium', 'high'];
+export const reasoningDefault = { enabled: true, effort: 'medium' };
+export const routerStrategies = ['auto', 'failover', 'round-robin', 'pinned'];
+export const permissionModes = ['ask', 'allow', 'deny'];
+export const themeNames = [
+    'tokyonight',
+    'catppuccin-mocha',
+    'catppuccin-latte',
+    'nord',
+    'gruvbox',
+    'monokai',
+    'clean-dark',
+];
+export const orbitXDefaults = {
+    // Default public Orbit X backend (custom domain overrides at wizard time).
+    url: 'https://orbit-x-rfj6.onrender.com',
+};
+export const openAIDefaults = {
+    url: 'https://api.openai.com/v1',
+};
+export const modelDefault = {
+    primary: 'gemini/gemini-2.5-flash',
+    fallback: [
+        'openrouter/qwen/qwen-2.5-coder-32b-instruct',
+        'groq/meta-llama/llama-3.3-70b-versatile',
+        'gemini/gemini-3.1-pro-preview',
+        'openrouter/deepseek/deepseek-v4-flash',
+    ],
+};
+export const routingDefault = {
+    strategy: 'auto',
+    maxRetries: 2,
+    retryDelayMs: 800,
+};
+export const keysDefault = { envOnly: true, file: '' };
+export const permissionsDefault = {
+    mode: 'ask',
+    allowCommands: [],
+    allowPaths: [],
+    denyCommands: [],
+    denyPaths: [],
+};
+export const toolsDefault = { shell: true, filesystem: true, search: true, timeoutMs: 30_000 };
+export const agentDefault = {
+    maxIterations: 16,
+    maxDelegations: 6,
+    contextBudgetTokens: 48_000,
+};
+export const orchestrationDefault = {
+    enabled: false,
+    maxLeadAgents: 2,
+    leads: [],
+};
+export const runtimeDefault = {
+    streamTimeoutMs: 120_000,
+    retryBackoffMs: 800,
+    retryBackoffMaxMs: 8_000,
+};
+export const uiDefault = {
+    showThinking: true,
+    autoCollapseTools: false,
+    maxTokensPerSecond: 0,
+    spinner: 'dots',
+};
+export const configSchema = z.object({
+    version: z.number().int().default(1),
+    firstRunComplete: z.boolean().default(false),
+    theme: z.enum(themeNames).default('tokyonight'),
+    provider: z.enum(providerNames).default('orbitx'),
+    model: z.object({
+        primary: z.string().default(modelDefault.primary),
+        fallback: z.array(z.string()).default([...modelDefault.fallback]),
+    }).default({ ...modelDefault }),
+    reasoning: z.object({
+        enabled: z.boolean().default(true),
+        effort: z.enum(effortLevels).default('medium'),
+    }).default({ ...reasoningDefault }),
+    routing: z.object({
+        strategy: z.enum(routerStrategies).default('auto'),
+        maxRetries: z.number().int().min(0).max(5).default(2),
+        retryDelayMs: z.number().int().min(0).max(5000).default(800),
+    }).default({ ...routingDefault }),
+    orbitx: z.object({
+        url: z.string().url().default(orbitXDefaults.url),
+        token: z.string().default(''),
+    }).default({ url: orbitXDefaults.url, token: '' }),
+    keys: z.object({
+        envOnly: z.boolean().default(true),
+        file: z.string().default(''),
+    }).default({ ...keysDefault }),
+    permissions: z.object({
+        mode: z.enum(permissionModes).default('ask'),
+        allowCommands: z.array(z.string()).default([]),
+        allowPaths: z.array(z.string()).default([]),
+        denyCommands: z.array(z.string()).default([]),
+        denyPaths: z.array(z.string()).default([]),
+    }).default({ ...permissionsDefault }),
+    tools: z.object({
+        shell: z.boolean().default(true),
+        filesystem: z.boolean().default(true),
+        search: z.boolean().default(true),
+        timeoutMs: z.number().int().min(1000).max(300_000).default(30_000),
+    }).default({ ...toolsDefault }),
+    agent: z.object({
+        maxIterations: z.number().int().min(1).max(64).default(16),
+        maxDelegations: z.number().int().min(0).max(20).default(6),
+        contextBudgetTokens: z.number().int().min(4000).max(200_000).default(48_000),
+    }).default({ ...agentDefault }),
+    orchestration: z
+        .object({
+        enabled: z.boolean().default(false),
+        maxLeadAgents: z.number().int().min(1).max(4).default(2),
+        leads: z
+            .array(z.object({
+            name: z.string().min(1).max(40),
+            systemPrompt: z.string().default(''),
+            model: z
+                .object({
+                primary: z.string(),
+                fallback: z.array(z.string()).default([]),
+            })
+                .default({ primary: modelDefault.primary, fallback: [...modelDefault.fallback] }),
+        }))
+            .default([]),
+    })
+        .default({ ...orchestrationDefault }),
+    runtime: z.object({
+        streamTimeoutMs: z.number().int().min(5000).max(600_000).default(120_000),
+        retryBackoffMs: z.number().int().min(100).max(5000).default(800),
+        retryBackoffMaxMs: z.number().int().min(1000).max(30_000).default(8000),
+    }).default({ ...runtimeDefault }),
+    ui: z.object({
+        showThinking: z.boolean().default(true),
+        autoCollapseTools: z.boolean().default(false),
+        maxTokensPerSecond: z.number().int().min(0).max(1000).default(0),
+        spinner: z.string().default('dots'),
+    }).default({ ...uiDefault }),
+});
+export function defaultConfig() {
+    return configSchema.parse({});
+}
+export function validateConfig(raw) {
+    return configSchema.parse(raw ?? {});
+}

package/dist/src/config/index.js

@@ -0,0 +1,57 @@
+import { mkdirSync, readFileSync, writeFileSync, statSync, chmodSync, renameSync } from 'node:fs';
+import { configPath, configDir } from '../utils/platform.js';
+import { defaultConfig, validateConfig } from './config-schema.js';
+export { defaultConfig, validateConfig } from './config-schema.js';
+/**
+ * Config persistence. Reads/writes JSON at the platform config path.
+ * Writes are atomic (tmp + rename) and never chmod-writable by group.
+ */
+function ensureConfigDir() {
+    mkdirSync(configDir(), { recursive: true });
+}
+function atomicWrite(path, data) {
+    ensureConfigDir();
+    const tmp = `${path}.tmp`;
+    writeFileSync(tmp, data, 'utf8');
+    chmodSync(tmp, 0o600);
+    renameSync(tmp, path);
+    chmodSync(path, 0o600);
+}
+export function loadConfig() {
+    try {
+        const raw = readFileSync(configPath(), 'utf8');
+        return validateConfig(JSON.parse(raw));
+    }
+    catch {
+        return defaultConfig();
+    }
+}
+export function saveConfig(config) {
+    atomicWrite(configPath(), JSON.stringify(config, null, 2));
+}
+export function configFileIsValid() {
+    try {
+        const raw = readFileSync(configPath(), 'utf8');
+        validateConfig(JSON.parse(raw));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function touchConfig() {
+    ensureConfigDir();
+    const cfg = loadConfig();
+    if (!configFileIsValid())
+        saveConfig(cfg);
+    return cfg;
+}
+export function configExists() {
+    try {
+        statSync(configPath());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}