@orbit-intelligence/orbit-agent 0.3.12

package/LICENSE

@@ -0,0 +1,16 @@
+Copyright (c) 2026 orbit-intelligence. All rights reserved.
+
+This package is closed source. All rights reserved by orbit-intelligence.
+
+No part of this software may be reproduced, distributed, or transmitted in any
+form or by any means without the prior written permission of the author, except
+for the user's own local execution of the unmodified package for its intended
+purpose.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,23 @@
+# orbit
+
+A premium pure-TypeScript coding-agent TUI for Termux and desktop terminals, powered by Orbit X.
+
+```bash
+npm i -g @orbit-intelligence/orbit-agent
+orbit
+```
+
+- Streaming TUI (thinking, tool calls, token counts) — zero native dependencies.
+- Provider keys live only in your private [Orbit X](https://orbit-x-rfj6.onrender.com) gateway; the client keeps a single endpoint token.
+- Auto-routing across Groq, Gemini, OpenRouter with failover: `orbitx/auto`, `groq/llama-3.3-70b-versatile`, `gemini/...`, `openrouter/...`.
+- First-run wizard (`orbit setup`); offline demo via `orbit demo`; `orbit help` for all subcommands.
+- UNLICENSED — closed source, © 2026 [orbit-intelligence](https://www.npmjs.com/~orbit-intelligence).
+
+## Docs
+
+- [`prompt-1.md`](./prompt-1.md) — agent/system specs
+- `npm run build` / `npm test` / `npm start`
+
+## Website
+
+[Orbit-agent-intelligence](https://orbit-agent-intelligence.onrender.com)

package/bin/orbit

@@ -0,0 +1,26 @@
+#!/bin/sh
+# orbit-agent bin launcher — works on Termux (no /usr/bin/env), Linux, macOS.
+# Follows npm symlinks to find the real package root, then runs dist/src/index.js.
+
+resolve_pkg_dir() {
+  _p="$1"
+  while [ -L "$_p" ]; do
+    _d="$(dirname "$_p")"
+    _p="$(readlink "$_p")"
+    case "$_p" in
+      /*) ;;
+      *) _p="$_d/$_p" ;;
+    esac
+  done
+  echo "$(dirname "$_p")"
+}
+
+PKG_DIR="$(resolve_pkg_dir "$0")"
+NODE_BIN="$(command -v node 2>/dev/null || command -v nodejs 2>/dev/null)"
+
+if [ -z "$NODE_BIN" ]; then
+  echo "orbit-agent: could not find 'node' on PATH (is Node.js installed?)" >&2
+  exit 1
+fi
+
+exec "$NODE_BIN" "$PKG_DIR/../dist/src/index.js" "$@"

package/dist/prompts/system.js

@@ -0,0 +1,80 @@
+import { isTermux, defaultShell, platformLabel } from '../src/utils/platform.js';
+export function buildSystemPrompt(config, cwd, extras) {
+    const env = isTermux() ? 'Termux (Android aarch64)' : platformLabel();
+    const shell = defaultShell();
+    const termuxBlock = isTermux()
+        ? `
+- This is Termux on Android (aarch64): limited CPU, RAM, battery, and network. Keep command timeouts short; avoid heavy builds, bulk downloads, and long-running daemons.
+- Install packages with \`pkg\` (Termux's package manager). Do NOT use \`apt\`, \`systemctl\`, \`service\`, \`sudo\`, or \`ssh\` unless clearly necessary — most system services do not exist here and will hang or error.
+- Avoid interactive commands (editors, full-screen TUIs, prompts) that can hang a session; use non-interactive flags (-y / --yes / --no-input / \`env CI=1\`).
+- Prefer the built-in file tools (read_file / glob / grep / edit_file) over shell cat/grep/sed for project work — faster and safer on mobile.
+- Mobile screens are small: keep command output short (truncate large dumps) and batch file operations into single commands. Prefer the built-in git tooling over shell git, and keep git output quiet (--no-advice --porcelain) when scripting.
+- Android restricts some kernel features; if a tool fails with EPERM/EACCES, adapt the approach instead of retrying the same call.`
+        : '';
+    const conventionsBlock = extras?.conventions && extras.conventions.trim().length > 0
+        ? `
+# Project conventions (loaded from AGENTS.md)
+These are the authoritative rules for this repository. They override generic guidance below when they conflict. Follow them exactly.
+${extras.conventions}`
+        : '';
+    const skillsBlock = extras?.skills && extras.skills.length > 0
+        ? `
+# Available skills
+When a user request matches one of these skills, load its instructions before starting. To load a skill body your model can call the \`load_project_skill\` tool; use the skill's name exactly as listed.
+${extras.skills.map((s) => `- \`${s.name}\` — ${s.summary}`).join('\n')}`
+        : '';
+    return `You are orbit-agent, an interactive terminal agent for software engineering tasks. You help users safely and efficiently, using the tools below and following these instructions strictly.
+
+# Operating environment
+- Platform: ${env}
+- Shell: ${shell}
+- Working directory: ${cwd}
+- You are a full agent: read, write, search, run commands, and iterate until the task is complete.
+${termuxBlock}
+${conventionsBlock}
+${skillsBlock}
+
+# Core mandates
+- Conventions: Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
+- Libraries/frameworks: NEVER assume a library or framework is available. Verify established usage in the project (imports, package.json, Cargo.toml, requirements.txt, etc.) before using anything.
+- Style: Mimic existing style, structure, typing, and architecture. Make the smallest change that satisfies the request.
+- Comments: Add code comments sparingly and only for *why*, not *what*. Never narrate your actions through comments.
+- Proactiveness: Fulfill the request thoroughly, including reasonable, directly implied follow-up actions — but do not take significant actions beyond the request's scope without confirming.
+- Confirm ambiguity: If a request is ambiguous or asks *how*, explain first instead of guessing.
+
+# When to use tools
+- Tools exist to get real information and take real actions — not to be used reflexively.
+- Greetings, chit-chat, thanks, and general questions (non-code): respond directly. Do NOT call tools.
+- Anything about this repository, the filesystem, or an actual codebase: inspect with tools (list_dir / glob / grep / read_file) BEFORE answering or acting. Never answer from memory about directories or files.
+- Writing code: read the relevant code first, edit surgically (prefer edit_file), then verify with the project's own checks.
+- If you cannot verify something, say you did not verify it rather than presenting a guess.
+
+# How you work
+1. Understand. For a real task, explore first (read_file / list_dir / glob / grep). NEVER hallucinate file contents.
+2. Plan. Prefer a clear, minimal plan, executed in small verifiable steps. A one-line plan stated before you start is fine; don't write an essay.
+3. Implement. Use the appropriate tool (prefer edit_file over write_file for surgical changes).
+4. Verify. Run the project's checks yourself before claiming success: \`npm test\`, \`node --test dist/tests/*.test.js\`, \`npm run typecheck\`, \`npm run build\` — as applicable. NEVER assume test commands; find them in package.json.
+5. Reflect. After a tool returns, read the result, note in one line what it tells you and what you're doing next, then decide: more work, or final answer. Keep working and iterating until the task is verifiably done — you decide when it is done, not a fixed number of steps. If a step yields unexpected results, adapt and continue.
+
+# Tool discipline
+- Explore with glob/grep before reading whole files. Use absolute paths with file tools.
+- run_shell: one focused command per call. Before commands that modify files or system state, give a brief explanation of purpose and impact. Avoid interactive commands that can hang; use non-interactive flags instead.
+- If a tool fails, read the error, adapt, and retry — do not repeat the identical failing command.
+- If a user cancels a tool call, respect it; do not retry unless they ask again.
+- Honor the permission policy: never modify files outside the working directory without explicit permission.
+
+# Output style
+- Be concise and direct. Keep responses short unless the user asks for detail.
+- Show your working across steps: a one-line intent before a tool call and a one-line finding/next step after each tool result. Do not recap the whole session at the end — just give the final answer.
+- Use Markdown for structure. Quote exact paths (path:line) when referring to code.
+- No emojis unless asked. Do not add code explanations unless asked.
+
+# Security
+- Never introduce code that exposes, logs, or commits secrets or API keys.
+- Do not delete, overwrite, or modify files outside the working directory without explicit user permission.
+
+# Inability
+- If you cannot or will not do something, say so briefly (1-2 sentences) and offer a helpful alternative; do not lecture.
+
+Begin.`;
+}

package/dist/src/cli/args.js

@@ -0,0 +1,145 @@
+export function parseArgs(argv) {
+    const args = {
+        setup: false,
+        run: false,
+        noColor: false,
+        version: false,
+        help: false,
+        yes: false,
+        yolo: false,
+        showKeys: false,
+        orchestrate: false,
+    };
+    const take = (i) => {
+        const v = argv[++i];
+        if (v === undefined)
+            throw new Error(`Missing value for '${argv[i - 1]}'\nRun orbit help for usage.`);
+        return v;
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        switch (a) {
+            // Flags
+            case '--setup':
+                args.setup = true;
+                break;
+            case '--run':
+                args.run = true;
+                break;
+            case '--orchestrate':
+                args.orchestrate = true;
+                break;
+            case '--yes':
+            case '-y':
+                args.yes = true;
+                break;
+            case '--yolo':
+                args.yolo = true;
+                args.yes = true;
+                break;
+            case '--no-color':
+                args.noColor = true;
+                break;
+            case '--version':
+            case '-v':
+                args.version = true;
+                break;
+            case '--help':
+            case '-h':
+                args.help = true;
+                break;
+            case '--show-keys':
+                args.showKeys = true;
+                break;
+            case '--theme':
+            case 'theme':
+                args.theme = take(i);
+                i++;
+                break;
+            case '--provider':
+            case 'provider':
+                args.provider = take(i);
+                i++;
+                break;
+            case '--model':
+            case 'model':
+                args.model = take(i);
+                i++;
+                break;
+            case '--session':
+            case 'session':
+                args.session = take(i);
+                i++;
+                break;
+            case '--cwd':
+            case 'cwd':
+                args.cwd = take(i);
+                i++;
+                break;
+            case '--log':
+            case 'log':
+                args.log = take(i);
+                i++;
+                break;
+            // Flagless subcommands
+            case 'setup':
+                args.setup = true;
+                break;
+            case 'run':
+                args.run = true;
+                break;
+            case 'orchestrate':
+                args.orchestrate = true;
+                break;
+            case 'version':
+                args.version = true;
+                break;
+            case 'help':
+                args.help = true;
+                break;
+            case 'yes':
+                args.yes = true;
+                break;
+            case 'yolo':
+                args.yolo = true;
+                args.yes = true;
+                break;
+            case 'nocolor':
+            case 'no-color':
+                args.noColor = true;
+                break;
+            default:
+                if (a.startsWith('-')) {
+                    throw new Error(`Unknown flag: ${a}\nRun orbit help for usage.`);
+                }
+                // Anything else is a bare prompt → single-shot run.
+                args.prompt = [args.prompt, a].filter(Boolean).join(' ');
+                break;
+        }
+    }
+    return args;
+}
+export const HELP = `orbit — a premium coding agent TUI for Termux & desktop terminals.
+
+Usage:
+  orbit                       start (setup wizard on first run)
+  orbit run "question"        single-shot: run one prompt headless, print the answer
+  orbit "question"            same as run (bare prompt)
+  orbit setup                 re-run the setup wizard
+  orbit orchestrate           orchestration mode: multiple lead agents collaborate
+  orbit theme <name>          set theme (tokyonight, catppuccin-mocha, nord, ...)
+  orbit provider <id>         force provider (orbitx, groq, gemini, openrouter, mock)
+  orbit model <id>            set primary model id (provider/name)
+  orbit cwd <path>            working directory (default: cwd)
+  orbit log <session-id>      print a session's event log (audit trail)
+  orbit session <id>          resume a prior session (--session)
+  orbit yes                   skip permissions prompts (auto-allow)
+  orbit yolo                  allow everything without asking
+  orbit nocolor               disable ANSI color
+  orbit version               print version
+  orbit help                  show this help
+
+All subcommands also work with --flag form (e.g. orbit --setup, orbit --help).
+
+Keys are read from environment variables (GROQ_API_KEY, GEMINI_API_KEY, OPENROUTER_API_KEY)
+or from ~/.config/orbit-agent/keys.json. Never from this binary.`;

package/dist/src/cli/orchestrate.js

@@ -0,0 +1,100 @@
+import { resolve } from 'node:path';
+import { ToolRegistry } from '../core/tools/registry.js';
+import { PermissionManager } from '../core/permissions/index.js';
+import { RoleRegistry } from '../core/orchestration/roles.js';
+import { OrchestrationSession } from '../core/orchestration/session.js';
+import { registerOrchestrationTools } from '../core/orchestration/tools.js';
+import { buildSystemPrompt } from '../../prompts/system.js';
+import { TuiApp } from '../tui/app.js';
+import { VERSION } from '../version.js';
+/**
+ * Orchestration mode: N lead agents collaborate on the user's turn with
+ * real agent→agent messaging, interrupts, shared context, and role delegation.
+ */
+export async function runOrchestrateCmd(opts) {
+    const { config, providers, bus, cwd } = opts;
+    const maxLeads = config.orchestration?.maxLeadAgents ?? 2;
+    const leads = config.orchestration?.leads?.length
+        ? config.orchestration.leads
+        : [
+            { name: 'Atlas', systemPrompt: '', model: config.model },
+            { name: 'Nova', systemPrompt: 'Focused on correctness: verify every claim, prefer small precise edits.', model: config.model },
+        ];
+    if (leads.length > maxLeads) {
+        console.error(`⚠  orchestration supports at most ${maxLeads} lead agents (config has ${leads.length}).`);
+        console.error('    Reduce orchestration.leads or raise orchestration.maxLeadAgents.');
+        return 1;
+    }
+    const sessionConfig = {
+        leads: leads.map((l) => ({
+            name: l.name,
+            systemPrompt: l.systemPrompt ?? '',
+            model: { primary: l.model.primary, fallback: [...(l.model.fallback ?? [])] },
+        })),
+        cwd: resolve(cwd),
+        maxLeadAgents: maxLeads,
+        contextBudgetTokens: config.agent?.contextBudgetTokens ?? 48_000,
+        toolTimeoutMs: config.tools?.timeoutMs ?? 30_000,
+        streamTimeoutMs: config.runtime?.streamTimeoutMs ?? 120_000,
+    };
+    const registry = new ToolRegistry({ cwd, canWrite: true, shell: config.tools.shell });
+    registerOrchestrationTools(registry);
+    const app = new TuiApp({
+        config,
+        bus,
+        onSubmit: (text) => submitQueued(text),
+        version: VERSION,
+    });
+    const permissions = new PermissionManager(config.permissions, {
+        ask: (prompt) => app.ask(prompt),
+    });
+    const session = new OrchestrationSession({
+        config: sessionConfig,
+        providers,
+        strategy: config.routing.strategy,
+        registry,
+        permissions,
+        roles: new RoleRegistry(),
+        bus,
+        baseSystemPrompt: buildSystemPrompt(config, cwd),
+        cwd,
+        maxTokensPerSecond: opts.maxTokensPerSecond,
+        contextBudgetTokens: config.agent?.contextBudgetTokens ?? 48_000,
+        reasoning: config.reasoning,
+    });
+    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();
+            try {
+                await session.handleUser(text);
+            }
+            catch (err) {
+                bus.emit('onError', err);
+            }
+        }
+        processing = false;
+    }
+    bus.emit('onSessionStatus', `orchestration session: ${session.agentIds.length} lead agent(s) ready`);
+    app.run();
+    return await new Promise((r) => {
+        process.once('SIGINT', () => {
+            for (const id of session.agentIds)
+                session.abortAgent(id);
+            app.destroy();
+            r(130);
+        });
+        process.once('SIGTERM', () => {
+            app.destroy();
+            r(143);
+        });
+    });
+}