@orbit-intelligence/orbit-agent 0.3.12

package/dist/src/utils/diff.js

@@ -0,0 +1,161 @@
+/**
+ * Minimal line-based unified diff. Pure, dependency-free: a classic LCS-based
+ * Myers-ish diff over lines with hunks, used for the diff review surface.
+ */
+export function unifiedDiff(before, after, label = 'file', context = 3) {
+    const a = before.split('\n');
+    const b = after.split('\n');
+    const ops = diffOp(a, b);
+    const hunks = buildHunks(a, b, ops, context);
+    if (hunks.length === 0)
+        return '';
+    const out = [`--- ${label}a`, `+++ ${label}b`];
+    for (const h of hunks) {
+        out.push(h.header);
+        for (const l of h.lines)
+            out.push(l);
+    }
+    return out.join('\n');
+}
+export function countChanges(diff) {
+    let added = 0;
+    let removed = 0;
+    for (const line of diff.split('\n')) {
+        if (line.startsWith('+') && !line.startsWith('+++'))
+            added++;
+        else if (line.startsWith('-') && !line.startsWith('---'))
+            removed++;
+    }
+    return { added, removed };
+}
+function diffOp(a, b) {
+    const n = a.length;
+    const m = b.length;
+    // LCS table — O(n*m), fine for typical source files (never past pairwise
+    // content, capped to avoid pathological memory use on gigantic dumps).
+    if (n * m > 4_000_000)
+        return a.map(() => -1);
+    const dp = new Uint16Array((n + 1) * (m + 1));
+    const W = m + 1;
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            dp[i * W + j] =
+                a[i] === b[j]
+                    ? dp[(i + 1) * W + j + 1] + 1
+                    : Math.max(dp[(i + 1) * W + j], dp[i * W + j + 1]);
+        }
+    }
+    const ops = new Array(n).fill(-1);
+    let i = 0;
+    let j = 0;
+    const trace = [];
+    while (i < n && j < m) {
+        if (a[i] === b[j]) {
+            trace.push(0);
+            i++;
+            j++;
+        }
+        else if (dp[(i + 1) * W + j] >= dp[i * W + j + 1]) {
+            trace.push(-1);
+            i++;
+        }
+        else {
+            trace.push(1);
+            j++;
+        }
+    }
+    while (i < n) {
+        trace.push(-1);
+        i++;
+    }
+    while (j < m) {
+        trace.push(1);
+        j++;
+    }
+    return trace;
+}
+function buildHunks(a, b, ops, context) {
+    const hunks = [];
+    let hunk = null;
+    let beforeStart = 0;
+    let afterStart = 0;
+    let beforeCount = 0;
+    let afterCount = 0;
+    let gap = 0;
+    const flush = () => {
+        if (hunk) {
+            hunk.header = `@@ -${beforeStart},${beforeCount} +${afterStart},${afterCount} @@`;
+            hunks.push(hunk);
+        }
+        hunk = null;
+        gap = 0;
+    };
+    // Two-pass: mark which lines belong to a hunk (with context padding),
+    // then build the hunks from the marks so deleted/inserted context appears
+    // only once.
+    const marked = ops.map((op) => op !== 0);
+    for (let i = 0; i < ops.length; i++) {
+        if (ops[i] !== 0) {
+            for (let k = Math.max(0, i - context); k <= Math.min(ops.length - 1, i + context); k++) {
+                marked[k] = true;
+            }
+        }
+    }
+    let ai = 0;
+    let bi = 0;
+    for (let i = 0; i < ops.length; i++) {
+        const op = ops[i];
+        if (marked[i]) {
+            if (op === 0) {
+                if (!hunk) {
+                    hunk = { header: '', lines: [] };
+                    beforeStart = ai + 1;
+                    afterStart = bi + 1;
+                }
+                beforeCount++;
+                afterCount++;
+                hunk.lines.push(` ${a[ai]}`);
+                ai++;
+                bi++;
+            }
+            else if (op === -1) {
+                if (!hunk) {
+                    hunk = { header: '', lines: [] };
+                    beforeStart = ai + 1;
+                    afterStart = bi + 1;
+                }
+                beforeCount++;
+                hunk.lines.push(`-${a[ai]}`);
+                ai++;
+            }
+            else {
+                if (!hunk) {
+                    hunk = { header: '', lines: [] };
+                    beforeStart = ai + 1;
+                    afterStart = bi + 1;
+                }
+                afterCount++;
+                hunk.lines.push(`+${b[bi]}`);
+                bi++;
+            }
+            gap = 0;
+        }
+        else {
+            if (op === 0) {
+                ai++;
+                bi++;
+            }
+            else if (op === -1) {
+                ai++;
+            }
+            else {
+                bi++;
+            }
+            gap++;
+            if (hunk && gap > context * 2)
+                flush();
+        }
+    }
+    flush();
+    return hunks;
+}

package/dist/src/utils/platform.js

@@ -0,0 +1,71 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+/**
+ * Platform detection and path helpers.
+ * Termux (Android aarch64) is detected by its environment signature.
+ */
+export function isTermux() {
+    return (process.env.PREFIX === '/data/data/com.termux/files/usr' ||
+        (process.env.ANDROID_ROOT != null &&
+            existsSync('/data/data/com.termux/files/usr/bin')));
+}
+export function isAndroid() {
+    return process.env.ANDROID_ROOT != null || process.platform === 'android';
+}
+export function isWindows() {
+    return process.platform === 'win32';
+}
+export function platformLabel() {
+    if (isTermux())
+        return 'termux';
+    return process.platform;
+}
+function xdgConfigHome() {
+    return process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
+}
+function xdgDataHome() {
+    return process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share');
+}
+export function configDir() {
+    return join(xdgConfigHome(), 'orbit-agent');
+}
+export function dataDir() {
+    return isTermux() ? join(homedir(), '.orbit-agent') : join(xdgDataHome(), 'orbit-agent');
+}
+export function sessionsDir() {
+    return join(dataDir(), 'sessions');
+}
+export function configPath() {
+    return join(configDir(), 'config.json');
+}
+export function keysPath() {
+    return join(configDir(), 'keys.json');
+}
+export function historyPath() {
+    return join(dataDir(), 'history.json');
+}
+export function logPath() {
+    return join(dataDir(), 'orbit-agent.log');
+}
+export function defaultShell() {
+    if (isWindows())
+        return process.env.COMSPEC || 'cmd.exe';
+    return process.env.SHELL || '/bin/sh';
+}
+export function supportsTrueColor() {
+    const ct = process.env.COLORTERM;
+    if (ct === 'truecolor' || ct === '24bit')
+        return true;
+    const term = process.env.TERM;
+    return term?.includes('truecolor') ?? false;
+}
+export function supportsUnicode() {
+    const env = process.env.LC_ALL || process.env.LC_CTYPE || process.env.LANG || '';
+    if (env.toUpperCase().includes('UTF'))
+        return true;
+    if (process.env.TERM_PROGRAM === 'vscode')
+        return true;
+    // Termux terminals are UTF-8 by default.
+    return isTermux();
+}

package/dist/src/utils/signals.js

@@ -0,0 +1,26 @@
+/**
+ * AbortSignal composition without relying on AbortSignal.any (portable across
+ * Node versions). Returns a signal that aborts when ANY input aborts, relaying
+ * the first non-generic reason.
+ */
+export function combineSignals(signals) {
+    const valid = signals.filter((s) => s !== undefined);
+    if (valid.length === 0) {
+        return new AbortController().signal;
+    }
+    if (valid.length === 1)
+        return valid[0];
+    const controller = new AbortController();
+    const propagate = () => {
+        const first = valid.find((s) => s.aborted);
+        controller.abort(first?.reason ?? new Error('aborted'));
+    };
+    for (const s of valid) {
+        if (s.aborted) {
+            propagate();
+            break;
+        }
+        s.addEventListener('abort', propagate, { once: true });
+    }
+    return controller.signal;
+}

package/dist/src/version.js

@@ -0,0 +1,4 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+export const VERSION = pkg.version;

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@orbit-intelligence/orbit-agent",
+  "version": "0.3.12",
+  "description": "orbit — a premium pure-TypeScript coding agent for Termux and desktop terminals, powered by Orbit X.",
+  "type": "module",
+  "license": "UNLICENSED",
+  "private": false,
+  "author": {
+    "name": "orbit-intelligence",
+    "url": "https://www.npmjs.com/~orbit-intelligence"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dexter-butcher/orbit-agent.git"
+  },
+  "homepage": "https://github.com/dexter-butcher/orbit-agent",
+  "bugs": {
+    "url": "https://github.com/dexter-butcher/orbit-agent/issues"
+  },
+  "bin": {
+    "orbit": "bin/orbit"
+  },
+  "main": "dist/src/index.js",
+  "files": [
+    "bin",
+    "dist/src",
+    "dist/prompts",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node node_modules/typescript/bin/tsc -p tsconfig.json",
+    "typecheck": "node node_modules/typescript/bin/tsc -p tsconfig.json --noEmit",
+    "dev": "node --watch src/index.ts",
+    "start": "node dist/index.js",
+    "test": "node --test \"dist/tests/*.test.js\"",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dependencies": {
+    "chalk": "^6.0.0",
+    "highlight.js": "^11.12.0",
+    "ink": "^7.1.1",
+    "marked": "^18.0.13",
+    "react": "^19.3.0",
+    "string-width": "^8.2.2",
+    "strip-ansi": "^7.2.0",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@types/react": "^19.3.0",
+    "typescript": "~5.9.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "tui",
+    "agent",
+    "llm",
+    "cli",
+    "termux",
+    "orbit",
+    "coding-agent",
+    "openai-compatible"
+  ],
+  "start": "node dist/src/index.js"
+}