@andrej7510/ai-router 1.0.0

package/README.md

@@ -0,0 +1,105 @@
+# ai-router
+
+CLI orchestrator that automatically routes tasks to **OpenAI Codex** or **Anthropic Claude** based on task complexity — and shifts more work to Codex when Claude's context window is running high.
+
+## Install
+
+```bash
+npm install -g ai-router
+```
+
+Requires `codex` and `claude` CLIs to be installed and authenticated:
+
+```bash
+npm install -g @openai/codex
+npm install -g @anthropic-ai/claude-code
+```
+
+## How it works
+
+Every task is scored 0–100 using keyword and length heuristics. Routing happens in two layers:
+
+**1. Intent detection (takes priority)**
+
+The task is matched against intent patterns first. Each intent maps to the most appropriate Claude model:
+
+| Intent | Trigger keywords | Model |
+|--------|-----------------|-------|
+| `plan` | design, architect, brainstorm, strategy, roadmap, scaffold | `claude-opus-4-5` |
+| `security` | security, encrypt, auth, vulnerability, threat, audit, pentest | `claude-opus-4-5` |
+| `debug` | why, broken, not working, crash, investigate, root cause | `claude-sonnet-4-6` |
+| `explain` | explain, how does, analyse, understand, overview, summarize | `claude-sonnet-4-6` |
+| `edit` | add, fix, rename, change, update, remove, refactor, extract | `claude-haiku-4-5` |
+| `test` / `format` | unit test, lint, typo, format, mock, coverage | `claude-haiku-4-5` |
+
+**2. Score-based fallback (no intent detected)**
+
+| Score | Model |
+|-------|-------|
+| ≥ 80  | `claude-opus-4-5` |
+| 60–79 | `claude-sonnet-4-6` |
+| < 60  | `claude-haiku-4-5` |
+
+Tasks that score below the routing threshold go to **Codex** regardless of intent.
+
+**3. Load-shedding**
+
+The routing threshold shifts automatically when Claude's context usage is high:
+
+| Claude load | Threshold | Effect |
+|-------------|-----------|--------|
+| < 80%       | 40        | Normal routing |
+| ≥ 80%       | 60        | Codex handles medium-complexity tasks |
+| ≥ 90%       | 80        | Almost everything goes to Codex |
+
+## Usage
+
+```bash
+# Auto-route based on complexity
+ai "add a null check to the confirm handler"       # → Codex
+ai "why is the serial handshake timing out"        # → Claude
+ai "brainstorm an encryption strategy"             # → Claude
+
+# Force a specific tool
+ai --codex  "write a unit test for deriveDigest"
+ai --claude "design the auth flow"
+
+# Preview routing without running
+ai --dry "your task here"
+
+# Set Claude context usage (0–100)
+ai --set-load 85
+
+# Show current load + threshold
+ai --status
+```
+
+## Load management
+
+When your Claude session is approaching its context limit, tell the router:
+
+```bash
+ai --set-load 85   # Claude at 85% → threshold raises to 60
+ai --set-load 92   # Claude at 92% → threshold raises to 80
+ai --set-load 0    # Back to normal
+```
+
+The load value is stored in `~/.ai-router/claude-load` and persists across sessions.
+
+## Routing examples
+
+| Task | Score | Intent | Model | At 85% | At 92% |
+|------|-------|--------|-------|--------|--------|
+| `rename function` | 10 | edit | — | Codex | Codex |
+| `add a null check` | 20 | edit | — | Codex | Codex |
+| `explain the escrow flow` | 42 | explain | `sonnet-4-6` | Codex | Codex |
+| `debug serial timeout` | 74 | debug | `sonnet-4-6` | `sonnet-4-6` | Codex |
+| `design an encryption strategy` | 86 | security | `opus-4-5` | `opus-4-5` | `opus-4-5` |
+| `architect the payment flow` | 78 | plan | `opus-4-5` | `opus-4-5` | Codex |
+| `why is the handshake failing` | 62 | debug | `sonnet-4-6` | `sonnet-4-6` | Codex |
+
+## Future improvements
+
+- Per-project `.ai-router.json` config (custom patterns + thresholds)
+- Auto-detect Claude context usage via API
+- Support additional AI CLI tools

package/ai.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+/**
+ * ai — Orchestrator that routes tasks to Codex or Claude based on complexity
+ *      and task intent, picking the cheapest Claude model that can do the job.
+ *
+ * Intent → model mapping:
+ *   plan / strategy / architecture → PLAN model   (most powerful)
+ *   security / crypto / audit      → SECURITY model
+ *   debug / investigate            → DEBUG model
+ *   explain / analyse              → EXPLAIN model
+ *   edit / refactor / simple fix   → EDIT model
+ *   test / format / typo           → EDIT model   (cheapest)
+ *   (no intent detected, fallback) → score-based  (haiku / sonnet / opus)
+ *
+ * Load-shedding thresholds:
+ *   Claude < 80% → threshold 40   (normal)
+ *   Claude ≥ 80% → threshold 60   (Codex picks up medium tasks)
+ *   Claude ≥ 90% → threshold 80   (almost everything → Codex)
+ *
+ * Usage:
+ *   ai "your task"                 → auto-route
+ *   ai --codex  "..."              → force Codex
+ *   ai --claude "..."              → force Claude
+ *   ai --dry    "..."              → show routing decision only
+ *   ai --set-load 85               → tell router Claude is at 85% context usage
+ *   ai --status                    → show current load + model table
+ */
+
+// ── Model map — update IDs here when new versions drop ───────────────────────
+const MODELS = {
+  plan:     "claude-opus-4-5",       // planning, architecture, strategy
+  security: "claude-opus-4-5",       // security, crypto, audits — high stakes
+  debug:    "claude-sonnet-4-6",     // debugging, investigation
+  explain:  "claude-sonnet-4-6",     // explanations, analysis
+  edit:     "claude-haiku-4-5",      // simple edits, tests, formatting
+  // score-based fallbacks (when no intent detected)
+  high:     "claude-opus-4-5",       // score ≥ 80
+  mid:      "claude-sonnet-4-6",     // score 60–79
+  low:      "claude-haiku-4-5",      // score < 60 (but above threshold)
+};
+
+import { execFileSync, execSync } from "child_process";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const LOAD_FILE = join(homedir(), ".ai-router", "claude-load");
+
+// ── Claude load helpers ───────────────────────────────────────────────────────
+
+function readLoad() {
+  if (!existsSync(LOAD_FILE)) return 0;
+  const val = parseInt(readFileSync(LOAD_FILE, "utf8").trim(), 10);
+  return isNaN(val) ? 0 : Math.max(0, Math.min(100, val));
+}
+
+function writeLoad(pct) {
+  writeFileSync(LOAD_FILE, String(pct), "utf8");
+}
+
+function thresholdForLoad(load) {
+  if (load >= 90) return 80;   // near full — only very complex tasks reach Claude
+  if (load >= 80) return 60;   // high load — Codex handles medium tasks too
+  return 40;                   // normal
+}
+
+function loadLabel(load) {
+  if (load >= 90) return "CRITICAL (≥90%)";
+  if (load >= 80) return "HIGH (≥80%)";
+  return "NORMAL";
+}
+
+// ── Intent detector ───────────────────────────────────────────────────────────
+
+const INTENT_PATTERNS = {
+  plan: /\b(plan|design|architect|brainstorm|strategy|roadmap|outline|structure|organiz|scaffold)\b/i,
+  security: /\b(security|encrypt|decrypt|auth(?:entication|oriz)?|vulnerabilit|threat|attack|ecdh|tls|aes|csrf|xss|injection|audit|pentest|harden)\b/i,
+  debug: /\b(debug|why (is|does|isn.t|doesn.t)|broken|not work(?:ing)?|doesn.t work|failing|crash(?:ing)?|error|investigate|trace|root cause|symptom)\b/i,
+  explain: /\b(explain|how does|what (is|does|are)|understand|analyse|analyze|overview|summarize|describe|clarify)\b/i,
+  edit: /\b(add|fix|rename|change|update|remove|delete|insert|set|replace|convert|refactor|extract|move|split|merge|cleanup|simplify)\b/i,
+  test: /\b(unit test|test for|write (a )?test|spec|coverage|mock|stub|format|lint|typo|comment|docstring)\b/i,
+};
+
+/**
+ * Detect the primary intent of a task string.
+ * Returns the first matching intent key, or null if none match.
+ * Priority order: plan > security > debug > explain > edit > test
+ */
+function detectIntent(task) {
+  for (const [intent, pattern] of Object.entries(INTENT_PATTERNS)) {
+    if (pattern.test(task)) return intent;
+  }
+  return null;
+}
+
+/**
+ * Pick the Claude model for a task.
+ * Intent takes priority; score-based fallback when intent is ambiguous.
+ */
+function claudeModel(task, s) {
+  const intent = detectIntent(task);
+  if (intent === "plan")     return { model: MODELS.plan,     intent };
+  if (intent === "security") return { model: MODELS.security, intent };
+  if (intent === "debug")    return { model: MODELS.debug,    intent };
+  if (intent === "explain")  return { model: MODELS.explain,  intent };
+  if (intent === "edit")     return { model: MODELS.edit,     intent };
+  if (intent === "test")     return { model: MODELS.edit,     intent };   // haiku is fine
+  // fallback: score bands
+  const model = s >= 80 ? MODELS.high : s >= 60 ? MODELS.mid : MODELS.low;
+  return { model, intent: null };
+}
+
+// ── Complexity scorer ─────────────────────────────────────────────────────────
+
+const COMPLEX_PATTERNS = [
+  // Intent: understand, plan, analyse
+  /\b(why|how does|explain|understand|analyse|analyze|brainstorm|design|architect|plan|strategy)\b/i,
+  // Scope: whole system, many files
+  /\b(refactor|rewrite|migrate|reorgani[sz]e|across|system|all files?)\b/i,
+  // Debugging unknown issues
+  /\b(debug|broken|not work|doesn.t work|failing|crash|error|issue|investigate)\b/i,
+  // Security / crypto
+  /\b(security|encrypt|decrypt|auth|vulnerabilit|threat|attack|ecdh|tls|aes)\b/i,
+  // Open-ended / soft
+  /\b(best (way|practice)|should (i|we)|what (if|about)|trade.?off|compare|vs\.?|pros? and cons?)\b/i,
+  // Multi-step
+  /\b(first .* then|step[- ]by[- ]step|and (also|then)|multiple)\b/i,
+];
+
+const SIMPLE_PATTERNS = [
+  // Narrow scope
+  /\b(add|fix|rename|change|update|remove|delete|insert|set|replace|convert)\b/i,
+  // File-local
+  /\b(function|variable|parameter|field|method|class|import|type|interface|const|let|var)\b/i,
+  // Tests / formatting
+  /\b(unit test|test for|format|lint|typo|comment|docstring|log (line|statement))\b/i,
+  // Short task marker
+  /^.{0,60}$/,
+];
+
+function score(task) {
+  let s = 50;
+  for (const p of COMPLEX_PATTERNS) if (p.test(task)) s += 12;
+  for (const p of SIMPLE_PATTERNS)  if (p.test(task)) s -= 10;
+  if (task.length > 200) s += 15;
+  if (task.length > 100) s += 8;
+  if (task.length < 60)  s -= 10;
+  return Math.max(0, Math.min(100, s));
+}
+
+// ── CLI arg parsing ───────────────────────────────────────────────────────────
+
+const args = process.argv.slice(2);
+
+let forceCodex  = false;
+let forceClaude = false;
+let dryRun      = false;
+let setLoad     = null;
+let showStatus  = false;
+const taskParts = [];
+
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  if (arg === "--codex")    { forceCodex  = true; continue; }
+  if (arg === "--claude")   { forceClaude = true; continue; }
+  if (arg === "--dry")      { dryRun      = true; continue; }
+  if (arg === "--status")   { showStatus  = true; continue; }
+  if (arg === "--set-load") { setLoad = parseInt(args[++i], 10); continue; }
+  taskParts.push(arg);
+}
+
+// ── --set-load ────────────────────────────────────────────────────────────────
+
+if (setLoad !== null) {
+  if (isNaN(setLoad) || setLoad < 0 || setLoad > 100) {
+    console.error("Usage: ai --set-load <0-100>");
+    process.exit(1);
+  }
+  writeLoad(setLoad);
+  const threshold = thresholdForLoad(setLoad);
+  console.log(`\n┌─ AI Router — Claude load updated ────────────────`);
+  console.log(`│  Claude usage: ${setLoad}%  [${loadLabel(setLoad)}]`);
+  console.log(`│  Threshold:    ${threshold}  (score < ${threshold} → Codex)`);
+  console.log(`└──────────────────────────────────────────────────\n`);
+  process.exit(0);
+}
+
+// ── --status ──────────────────────────────────────────────────────────────────
+
+if (showStatus) {
+  const load      = readLoad();
+  const threshold = thresholdForLoad(load);
+  console.log(`\n┌─ AI Router — Status ──────────────────────────────`);
+  console.log(`│  Claude usage: ${load}%  [${loadLabel(load)}]`);
+  console.log(`│  Threshold:    ${threshold}  (score < ${threshold} → Codex)`);
+  console.log(`│`);
+  console.log(`│  Intent-based routing (takes priority over score):`);
+  console.log(`│    plan     → ${MODELS.plan}`);
+  console.log(`│    security → ${MODELS.security}`);
+  console.log(`│    debug    → ${MODELS.debug}`);
+  console.log(`│    explain  → ${MODELS.explain}`);
+  console.log(`│    edit     → ${MODELS.edit}`);
+  console.log(`│    test     → ${MODELS.edit}`);
+  console.log(`│`);
+  console.log(`│  Score fallback (no intent detected):`);
+  console.log(`│    score ≥ 80  → ${MODELS.high}`);
+  console.log(`│    score 60–79 → ${MODELS.mid}`);
+  console.log(`│    score < 60  → ${MODELS.low}`);
+  console.log(`│`);
+  console.log(`│  Update with: ai --set-load <0-100>`);
+  console.log(`└──────────────────────────────────────────────────\n`);
+  process.exit(0);
+}
+
+// ── Require a task ────────────────────────────────────────────────────────────
+
+const task = taskParts.join(" ").trim();
+
+if (!task) {
+  console.error(`
+ai — AI task router (Codex vs Claude)
+
+Usage:
+  ai "your task here"
+  ai --codex  "force codex"
+  ai --claude "force claude"
+  ai --dry    "show routing only, don't run"
+  ai --set-load 85     set Claude context usage (0-100)
+  ai --status          show current load + threshold
+  `);
+  process.exit(1);
+}
+
+// ── Route ─────────────────────────────────────────────────────────────────────
+
+const load      = readLoad();
+const THRESHOLD = thresholdForLoad(load);
+const loadNote  = load >= 80 ? `  ⚡ Claude at ${load}% — threshold lowered to ${THRESHOLD}` : "";
+
+let tool;
+let reason;
+let model  = null;   // only set when routing to Claude
+let intent = null;
+
+const s = score(task);
+
+if (forceCodex) {
+  tool   = "codex";
+  reason = "forced via --codex";
+} else if (forceClaude) {
+  tool   = "claude";
+  ({ model, intent } = claudeModel(task, s));
+  reason = `forced via --claude`;
+} else {
+  if (s >= THRESHOLD) {
+    tool   = "claude";
+    ({ model, intent } = claudeModel(task, s));
+    reason = `score ${s}/100 ≥ ${THRESHOLD}`;
+  } else {
+    tool   = "codex";
+    reason = `score ${s}/100 < ${THRESHOLD}`;
+  }
+}
+
+const intentLabel = intent ? `  [${intent}]` : "";
+console.log(`\n┌─ AI Router ──────────────────────────────────────`);
+console.log(`│  Task:   ${task.slice(0, 72)}${task.length > 72 ? "…" : ""}`);
+console.log(`│  Route:  ${tool.toUpperCase()}${model ? `  →  ${model}` : ""}${intentLabel}  (${reason})`);
+if (loadNote) console.log(`│ ${loadNote}`);
+console.log(`└──────────────────────────────────────────────────\n`);
+
+if (dryRun) process.exit(0);
+
+// ── Execute ───────────────────────────────────────────────────────────────────
+
+const cmd  = tool === "codex" ? "codex" : "claude";
+const argv = tool === "codex"
+  ? ["exec", "--sandbox", "workspace-write", task]
+  : ["--model", model, task];
+
+try {
+  execFileSync(cmd, argv, { stdio: "inherit" });
+} catch (e) {
+  if (e.status) process.exit(e.status);
+  console.error(e.message);
+  process.exit(1);
+}

package/claude-load

@@ -0,0 +1 @@
+0

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@andrej7510/ai-router",
+  "version": "1.0.0",
+  "description": "CLI that routes tasks to OpenAI Codex or Claude based on complexity, with automatic load-shedding when Claude context is high",
+  "type": "module",
+  "bin": {
+    "ai": "ai.js"
+  },
+  "keywords": [
+    "ai",
+    "claude",
+    "codex",
+    "openai",
+    "anthropic",
+    "cli",
+    "orchestration",
+    "routing"
+  ],
+  "author": "andrej7510",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}