orcacompass 0.0.0-stage → 0.1.0

package/dist/routing/orca-settings.js

@@ -0,0 +1,111 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homeDir } from '../paths.js';
+import { readTextFile } from '../placements/agents/deps.js';
+// Orca's own rule for profile ids (profile-state-active-location).
+const PROFILE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** Orca's userData folder, resolved as the Orca CLI does. */
+export function orcaUserDataPath(env, platform, home) {
+    if (env.ORCA_USER_DATA_PATH)
+        return env.ORCA_USER_DATA_PATH;
+    if (platform === 'darwin')
+        return join(home, 'Library', 'Application Support', 'orca');
+    if (platform === 'win32')
+        return env.APPDATA ? join(env.APPDATA, 'orca') : undefined;
+    return join(env.XDG_CONFIG_HOME || join(home, '.config'), 'orca');
+}
+function activeProfile(deps, userData) {
+    const index = join(userData, 'orca-profile-index.json');
+    const texts = [index, `${index}.bak`].map(deps.readFile).filter((t) => t !== undefined);
+    if (texts.length === 0)
+        return { known: false, reason: `Orca profile index not found (${index})` };
+    for (const text of texts) {
+        try {
+            const data = JSON.parse(text);
+            if (!isObj(data) || !Array.isArray(data.profiles))
+                continue;
+            const id = data.activeProfileId;
+            if (typeof id === 'string' && PROFILE_ID.test(id) && data.profiles.some((p) => isObj(p) && p.id === id))
+                return id;
+        }
+        catch {
+            // try the backup copy
+        }
+    }
+    return { known: false, reason: `cannot resolve the active Orca profile from ${index}` };
+}
+function fromSettings(settings, source) {
+    if (!isObj(settings) || !Array.isArray(settings.disabledTuiAgents)) {
+        return { known: false, reason: `Orca settings in ${source} have no disabledTuiAgents list` };
+    }
+    return { known: true, disabled: settings.disabledTuiAgents.filter((a) => typeof a === 'string'), source };
+}
+export async function readOrcaAgents(deps = defaultDeps()) {
+    const userData = orcaUserDataPath(deps.env, deps.platform, deps.home);
+    if (!userData)
+        return { known: false, reason: 'APPDATA is not set, so the Orca folder is unknown' };
+    const profile = activeProfile(deps, userData);
+    if (typeof profile !== 'string')
+        return profile;
+    const dir = join(userData, 'profiles', profile);
+    const db = join(dir, 'profile-state.db');
+    const jsonFile = join(dir, 'orca-data.json');
+    try {
+        // Once the SQLite state exists Orca treats it as the authority; orca-data.json may be stale.
+        if (deps.exists(db)) {
+            const payload = await deps.readSettingsPayload(db);
+            if (payload === undefined)
+                return { known: false, reason: `no settings in ${db}` };
+            return fromSettings(JSON.parse(payload), db);
+        }
+        const text = deps.readFile(jsonFile);
+        if (text === undefined)
+            return { known: false, reason: `Orca settings not found in ${dir}` };
+        const data = JSON.parse(text);
+        return fromSettings(isObj(data) ? data.settings : undefined, jsonFile);
+    }
+    catch (e) {
+        return { known: false, reason: `cannot read Orca settings: ${e instanceof Error ? e.message : String(e)}` };
+    }
+}
+/** Opens profile-state.db read-only, reads the settings row and closes it at once. Needs node:sqlite (Node 22.5+). */
+export async function readSettingsPayload(dbPath) {
+    const { DatabaseSync } = await importSqlite();
+    const db = new DatabaseSync(dbPath, { readOnly: true });
+    try {
+        const row = db.prepare('SELECT payload FROM profile_state_documents WHERE domain = ?').get('settings');
+        return typeof row?.payload === 'string' ? row.payload : undefined;
+    }
+    finally {
+        db.close();
+    }
+}
+/** node:sqlite without its one-time ExperimentalWarning on stderr. */
+async function importSqlite() {
+    const emitWarning = process.emitWarning;
+    process.emitWarning = ((warning, ...rest) => {
+        if (String(warning instanceof Error ? warning.message : warning).includes('SQLite'))
+            return;
+        emitWarning.call(process, warning, ...rest);
+    });
+    try {
+        return await import('node:sqlite');
+    }
+    catch {
+        throw new Error(`this Node.js (${process.version}) has no node:sqlite; Node 22.5 or later is needed`);
+    }
+    finally {
+        process.emitWarning = emitWarning;
+    }
+}
+function defaultDeps() {
+    return {
+        env: process.env,
+        platform: process.platform,
+        home: homeDir(),
+        readFile: readTextFile,
+        exists: existsSync,
+        readSettingsPayload,
+    };
+}

package/dist/routing/orca-usage.js

@@ -0,0 +1,85 @@
+// Orca has no usage entry for Muse; listing it reports that instead of "not reachable".
+const agents = ['claude', 'codex', 'cursor', 'grok', 'antigravity', 'muse'];
+const isNumber = (x) => typeof x === 'number' && Number.isFinite(x);
+export async function readOrcaUsage(run) {
+    try {
+        const result = await run('orca', ['account', 'list', '--json'], { timeoutMs: 20_000 });
+        if (result.code !== 0 || result.error) {
+            throw new Error(result.error || result.stderr.trim() || `command exited with code ${result.code}`);
+        }
+        const data = JSON.parse(result.stdout);
+        if (data?.ok !== true) {
+            const error = data?.error;
+            throw new Error(typeof error === 'string' ? error : error?.message || 'account list failed');
+        }
+        const rateLimits = data.result?.rateLimits;
+        if (!rateLimits || typeof rateLimits !== 'object' || Array.isArray(rateLimits)) {
+            throw new Error('account list response has no rate limits');
+        }
+        return Object.fromEntries(agents.map((agent) => {
+            const source = rateLimits[agent] ?? {};
+            const pools = {};
+            // A pool with a missing number is skipped rather than read as 0 % used.
+            const addPool = (name, pool, kind = name === 'session' ? 'session' : 'long') => {
+                if (pool == null)
+                    return;
+                const { usedPercent, windowMinutes, resetsAt } = pool;
+                if (!isNumber(usedPercent) || !isNumber(windowMinutes) || !isNumber(resetsAt))
+                    return;
+                // Two buckets under one name (an agy group with two weekly limits) keep the tighter one.
+                if (pools[name] && pools[name].usedPercent >= usedPercent)
+                    return;
+                pools[name] = { name, kind, usedPercent, windowMinutes, resetsAt };
+            };
+            if (agent === 'cursor') {
+                addPool('monthly', source.monthly);
+                for (const bucket of source.buckets ?? []) {
+                    if (typeof bucket?.name === 'string')
+                        addPool(`bucket:${bucket.name}`, bucket);
+                }
+            }
+            else if (agent === 'grok') {
+                addPool('weekly', source.weekly);
+                addPool('monthly', source.monthly);
+            }
+            else if (agent === 'antigravity' && (source.buckets ?? []).some((b) => typeof b?.group === 'string')) {
+                // agy bills each quota group ("Gemini Models", "Claude and GPT models") separately, so each group gets
+                // its own pools; Orca's session and weekly are only the tightest across groups.
+                for (const bucket of source.buckets ?? []) {
+                    if (typeof bucket?.group !== 'string')
+                        continue;
+                    if (bucket.windowMinutes === 300)
+                        addPool(`bucket:${bucket.group} 5h`, bucket, 'session');
+                    else if (isNumber(bucket.windowMinutes) && bucket.windowMinutes > 0)
+                        addPool(`bucket:${bucket.group}`, bucket, 'long');
+                }
+            }
+            else {
+                // Without quota groups (older Orca), Antigravity falls back to Orca's tightest session and weekly.
+                addPool('session', source.session);
+                addPool('weekly', source.weekly);
+                if (agent === 'claude')
+                    addPool('fableWeekly', source.fableWeekly);
+            }
+            // Only an explicit 'unavailable' (signed out / CLI missing) excludes the agent;
+            // a transient or unrecognised status keeps it as a low-confidence candidate.
+            const status = source.status === 'ok' || source.status === 'unavailable' ? source.status : 'unknown';
+            const usage = {
+                agent,
+                status,
+                pools,
+                ...(source.updatedAt !== undefined ? { updatedAt: source.updatedAt } : {}),
+                ...(status !== 'ok'
+                    ? { error: source.error || (rateLimits[agent] ? `Orca usage ${source.status ?? 'status missing'}` : `Orca reports no usage for ${agent}`) }
+                    : {}),
+            };
+            return [agent, usage];
+        }));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return Object.fromEntries(agents.map((agent) => [agent, {
+                agent, status: 'unknown', pools: {}, error: `Orca not reachable: ${message}`,
+            }]));
+    }
+}

package/dist/routing/pace.js

@@ -0,0 +1,52 @@
+/** Below this elapsed fraction a projection is mostly noise, so usage is not extrapolated. */
+export const MIN_ELAPSED_TO_PROJECT = 0.1;
+/**
+ * Weight, as a fraction of the window, of the even-pace assumption in the headroom estimate. Early in a
+ * window there is little history, so the window is assumed to be used up evenly; the observed pace takes
+ * over as the window progresses.
+ */
+export const EVEN_PACE_WEIGHT = 0.1;
+/**
+ * Expected used fraction at reset: what is used so far plus the rest of the window at the estimated pace.
+ * The pace (fraction of the window's capacity per window) blends the observed pace with an even pace of 1
+ * weighted as EVEN_PACE_WEIGHT of a window of history. The observed pace is measured over at least that
+ * much of the window, so a burst right after a reset (some windows start on first use) is not extrapolated.
+ */
+export function expectedUse(used, elapsed) {
+    const observed = used / Math.max(elapsed, EVEN_PACE_WEIGHT);
+    const weight = elapsed / (elapsed + EVEN_PACE_WEIGHT);
+    const pace = weight * observed + (1 - weight);
+    return used + pace * (1 - elapsed);
+}
+/**
+ * Spare capacity counts in full only when it resets within this horizon. Spare capacity that resets later
+ * is less urgent to use (and its forecast less certain), so it counts in proportion: half at two weeks.
+ */
+export const URGENCY_HORIZON_MS = 7 * 86_400_000;
+/** The headroom a route ranks by: positive headroom scaled down when its reset is beyond the urgency horizon. */
+export function rankHeadroom(headroom, resetsAt, now) {
+    const remaining = resetsAt - now;
+    return headroom > 0 && remaining > URGENCY_HORIZON_MS ? headroom * (URGENCY_HORIZON_MS / remaining) : headroom;
+}
+export function poolState(pool, now, t) {
+    const expired = pool.resetsAt <= now;
+    const windowMs = pool.windowMinutes * 60_000;
+    const elapsed = windowMs > 0 ? Math.min(1, Math.max(0, 1 - (pool.resetsAt - now) / windowMs)) : 0;
+    const headroom = 1 - expectedUse(pool.usedPercent / 100, elapsed);
+    const limit = pool.kind === 'session' ? t.sessionPercent : t.longPercent;
+    return { expired, blocked: !expired && pool.usedPercent >= limit, headroom, elapsed };
+}
+/** Usage at the window's reset if the current pace holds: used% / elapsed fraction. */
+export function projectPool(pool, now) {
+    const { elapsed } = poolState(pool, now, { longPercent: Infinity, sessionPercent: Infinity });
+    const tooEarly = elapsed < MIN_ELAPSED_TO_PROJECT;
+    const projected = tooEarly ? pool.usedPercent : pool.usedPercent / elapsed;
+    return {
+        pool: pool.name,
+        usedPercent: pool.usedPercent,
+        elapsedPercent: Math.round(elapsed * 100),
+        projectedPercent: Math.round(projected * 10) / 10,
+        tooEarly,
+        resetsAt: pool.resetsAt,
+    };
+}

package/dist/routing/rejection.js

@@ -0,0 +1,58 @@
+// Each agent CLI's words for "cannot use this model", as printed when launched with a model it lacks:
+//   codex        The 'claude-opus-5-5' model is not supported when using Codex with a ChatGPT account.
+//   claude       There's an issue with the selected model (gpt-6-terra). It may not exist or you may not have access to it.
+//   cursor       Cannot use this model: claude-opus-9-9. Available models: auto, ...
+//   grok         Couldn't set model 'grok-9-fake': Invalid params: "unknown model id".
+//   antigravity  invalid model selection (--model "gemini-9-fake" ...): model gemini-9-fake is not recognized as a known model ...
+//   opencode     Error: Model unavailable: openrouter/fake/nonexistent-9
+const REFUSAL = /model is not supported|issue with the selected model|cannot use this model|couldn'?t set model|unknown model id|invalid model selection|not recognized as a known model|model unavailable/i;
+/**
+ * The agent's line refusing `model`, if the output has one. The line must name the model, so a worker's
+ * own output about other models never counts. Long lines wrap, so each line is also tried joined with the next.
+ */
+export function findRejection(model, lines) {
+    const id = model.toLowerCase();
+    const rows = lines.map((l) => l.trim());
+    const refuses = (text) => text.toLowerCase().includes(id) && REFUSAL.test(text);
+    const single = rows.find(refuses);
+    if (single)
+        return clean(single);
+    for (let i = 0; i + 1 < rows.length; i++) {
+        for (const text of [`${rows[i]}${rows[i + 1]}`, `${rows[i]} ${rows[i + 1]}`])
+            if (refuses(text))
+                return clean(text);
+    }
+    return undefined;
+}
+/** Drops the agent's decoration ("■ ", "ERROR: "), Cursor's list of available models and a sentence cut off by wrapping. */
+function clean(line) {
+    const text = line
+        .replace(/^[^\p{L}\p{N}]+/u, '')
+        .replace(/^(error|warning):\s*/i, '')
+        .split(/\s*Available models:/i)[0]
+        .trim()
+        .replace(/([.!?]["')\]]?)\s+[^.!?]*$/, '$1');
+    return text.length > 240 ? `${text.slice(0, 239)}…` : text;
+}
+/** Rejections seen less than `ttlHours` ago. */
+export function activeRejections(list, now, ttlHours) {
+    return list.filter((r) => now - r.at < ttlHours * 3_600_000);
+}
+/** Parses the saved rejections file, dropping malformed entries; empty when missing or invalid. */
+export function parseRejections(text) {
+    let data;
+    try {
+        data = text === undefined ? undefined : JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+    const list = data?.rejections;
+    if (!Array.isArray(list))
+        return [];
+    return list.filter((r) => typeof r?.agent === 'string' && typeof r?.model === 'string' && typeof r?.message === 'string' && Number.isFinite(r?.at));
+}
+/** The list with `r` added, replacing an older entry for the same agent and model. */
+export function withRejection(list, r) {
+    return [...list.filter((x) => x.agent !== r.agent || x.model !== r.model), r];
+}

package/dist/routing/rejections.js

@@ -0,0 +1,18 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { readTextFile } from '../placements/agents/deps.js';
+import { activeRejections, parseRejections, withRejection } from './rejection.js';
+import { cacheDir } from '../paths.js';
+// Models an agent refused at launch, kept in the cache folder: it is observed state, safe to delete.
+const FILE = 'rejected-models.json';
+export function readRejections(readFile = readTextFile, dir = cacheDir()) {
+    return parseRejections(readFile(join(dir, FILE)));
+}
+export function writeRejections(list, dir = cacheDir()) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, FILE), `${JSON.stringify({ rejections: list }, null, 2)}\n`);
+}
+/** Saves `r`, replacing an older entry for the same agent and model and dropping expired ones. */
+export function recordRejection(r, ttlHours, dir = cacheDir()) {
+    writeRejections(activeRejections(withRejection(readRejections(readTextFile, dir), r), r.at, ttlHours), dir);
+}