prompt-router 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ege
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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,245 @@
+# prompt-router
+
+**Route every prompt to the AI that deserves it.**
+
+[![CI](https://github.com/PTB-0/prompt-router/actions/workflows/ci.yml/badge.svg)](https://github.com/PTB-0/prompt-router/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Node >= 18](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg)](package.json)
+
+Sending "what's the capital of France?" to a frontier coding agent is a waste. Sending "build the production feature" to a 7B model is a disaster. **prompt-router** ends both: it optimizes your prompt, detects what you actually want, and dispatches it to the right backend — automatically, with a one-key override.
+
+> **Make the simple work cheap. Make the hard work easy.**
+
+```
+$ prompt-router "fix the login bug in auth.ts"
+
+  ────────────────────────────────────────────────────────
+  prompt-router — optimized & routed
+  ────────────────────────────────────────────────────────
+
+  ORIGINAL
+  fix the login bug in auth.ts
+
+  OPTIMIZED
+  In auth.ts, identify and fix the bug causing login failures.
+  Check token validation and session handling. Keep the change
+  minimal and do not modify unrelated files.
+
+  ROUTE → Claude Code
+  (code, complexity 0.4, confidence 0.9)
+
+  ────────────────────────────────────────────────────────
+  [Y]es  [n]o, original  [e]dit  [c]laude  [l]ocal  [o]penrouter  (15s timeout → Y):
+```
+
+---
+
+## Table of contents
+
+- [How it works](#how-it-works)
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Usage](#usage)
+- [The plan-first pipeline](#the-plan-first-pipeline)
+- [Local models](#local-models)
+- [Configuration](#configuration)
+- [Graceful degradation](#graceful-degradation)
+- [Privacy](#privacy)
+- [Development](#development)
+- [Roadmap](#roadmap)
+- [Related](#related)
+
+---
+
+## How it works
+
+One free LLM call on [OpenRouter](https://openrouter.ai) does two jobs at once: it **rewrites your prompt** to be precise and actionable, and it **classifies** it. Instant heuristics (code verbs in English and Turkish, file references, whether you're inside a repo) pre-filter the obvious cases before the network is even touched.
+
+```
+                     ┌──────────────────────────────┐
+       prompt ──────▶│   optimize + classify        │   one free LLM call
+                     │   (+ instant heuristics)     │
+                     └──────────────┬───────────────┘
+                                    │
+                  ┌─────────────────┼──────────────────┐
+                  ▼                 ▼                  ▼
+             code task        simple question     broad question
+                  │                 │                  │
+         complex? ──▶ draft plan    ▼                  ▼
+                  │   you approve   local model     OpenRouter
+                  ▼                 (LM Studio,     (strong free model
+             Claude Code            Ollama, ...)     + fallback chain)
+```
+
+| Your prompt looks like… | Goes to | Why |
+|---|---|---|
+| A coding task | **Claude Code** | Agentic execution where it matters |
+| A *complex* coding task | **Claude Code + plan** | A free model drafts an implementation plan first; you review it; Claude starts with a head start instead of exploring |
+| A quick question | **Your local model** | Instant, free, private, no rate limits |
+| A broad, open-ended question | **OpenRouter free model** | Long-form answers without burning Claude usage |
+
+**The router is deliberately paranoid.** Misrouting a code task to a small model costs you real work; over-serving a question only costs tokens. So whenever signals conflict or confidence is low, it escalates to the stronger backend — and you always get the confirmation prompt with single-key overrides.
+
+## Installation
+
+```bash
+npm install -g prompt-router
+```
+
+Requires Node.js ≥ 18 and the [Claude Code CLI](https://claude.com/claude-code) for the coding route.
+
+## Quick start
+
+**1.** Get a free API key at [openrouter.ai](https://openrouter.ai) and create `~/.config/prompt-router/.env`:
+
+```env
+OPENROUTER_API_KEY=sk-or-v1-xxxxxxxxxxxxxxxxxxxxxxxx
+```
+
+**2.** *(Optional but recommended)* Run a local model with [LM Studio](https://lmstudio.ai) — prompt-router will even start the server for you via `lms server start`. No local model? Simple questions fall back to OpenRouter automatically.
+
+**3.** Route something:
+
+```bash
+prompt-router "what is a monad?"
+```
+
+## Usage
+
+```bash
+prompt-router "fix the race condition in the session store"   # → Claude Code (plan-first if complex)
+prompt-router "what's the difference between TCP and UDP?"    # → local model
+prompt-router "compare event sourcing with CRUD for a bank"   # → OpenRouter
+
+prompt-router -c "and which one scales better?"   # follow-up: carries conversation memory
+prompt-router --to local "explain this simply"    # force a backend (claude | local | openrouter)
+prompt-router --no-route "quick edit"             # skip everything, straight to Claude Code
+prompt-router --stats                             # how much Claude usage you've saved
+prompt-router --clear-session                     # forget the stored conversation
+```
+
+Every routed prompt shows the confirmation bar first:
+
+| Key | Action |
+|---|---|
+| `Y` / Enter / timeout | Accept the optimized prompt and the chosen route |
+| `n` | Keep your original wording (same route) |
+| `e` | Edit the optimized prompt in `$EDITOR` |
+| `c` / `l` / `o` | Override the route: **c**laude, **l**ocal, **o**penrouter |
+
+## The plan-first pipeline
+
+For code tasks classified above the complexity threshold, prompt-router inserts one extra step before Claude Code starts:
+
+1. A strong free model drafts a concise, numbered implementation plan.
+2. The plan is shown to you — accept it, edit it, or skip it.
+3. The approved plan is attached to your prompt, so Claude Code begins executing instead of exploring.
+
+You spend zero premium tokens on planning, and the expensive agent gets a map. This is the "make the hard work easy" half of the deal.
+
+## Local models
+
+Any OpenAI-compatible server works — LM Studio, Ollama, llama.cpp, vLLM:
+
+- **LM Studio** (default): prompt-router probes `http://localhost:1234/v1`, and if the server is down it runs `lms server start` and waits for it to come up.
+- **Ollama or anything else**: point `local.baseUrl` at it (e.g. `http://localhost:11434/v1`) and set your model name.
+- **No GPU?** Set `local.enabled: false` (or just don't run a server) — simple questions route to OpenRouter instead. Nothing breaks.
+
+## Configuration
+
+Everything lives in `~/.config/prompt-router/` (override the directory with `PROMPT_ROUTER_DIR`). All fields are optional — these are the defaults:
+
+```jsonc
+// ~/.config/prompt-router/config.json
+{
+  "local": {
+    "baseUrl": "http://localhost:1234/v1",
+    "model": "gemma-4-12b-qat",
+    "autoStart": true,          // try `lms server start` when the server is down
+    "enabled": true             // false = never route locally
+  },
+  "openrouter": {
+    "baseUrl": "https://openrouter.ai/api/v1",
+    "classifierModels": [       // fallback chains — first healthy model wins
+      "meta-llama/llama-3.1-8b-instruct:free",
+      "google/gemma-2-9b-it:free",
+      "mistralai/mistral-7b-instruct:free"
+    ],
+    "answerModels": [
+      "meta-llama/llama-3.3-70b-instruct:free",
+      "deepseek/deepseek-chat:free",
+      "google/gemma-2-9b-it:free"
+    ],
+    "planModels": [
+      "meta-llama/llama-3.3-70b-instruct:free",
+      "deepseek/deepseek-chat:free",
+      "meta-llama/llama-3.1-8b-instruct:free"
+    ]
+  },
+  "thresholds": {
+    "confidence": 0.6,          // below this, the route is flagged for your attention
+    "planComplexity": 0.7       // at or above this, code tasks get the plan-first pipeline
+  },
+  "session": { "maxMessages": 12 },
+  "logging": { "routingLog": false },
+  "timeoutMs": 8000
+}
+```
+
+Free models come and go — the model lists are **fallback chains you can edit without waiting for a release**.
+
+| Environment variable | Overrides |
+|---|---|
+| `OPENROUTER_API_KEY` | API key (required for classification, deep answers, plans) |
+| `PROMPT_ROUTER_LOCAL_URL` | `local.baseUrl` |
+| `PROMPT_ROUTER_LOCAL_MODEL` | `local.model` |
+| `PROMPT_ROUTER_TIMEOUT` | `timeoutMs` |
+| `PROMPT_ROUTER_DIR` | Config/session/stats directory |
+
+## Graceful degradation
+
+prompt-router assumes things fail and never leaves you stranded:
+
+| When… | It… |
+|---|---|
+| The classifier is down or you have no API key | Sends your original prompt straight to Claude Code |
+| The local server is down and can't be started | Falls back to OpenRouter |
+| A free model is rate-limited mid-stream | Retries with the next model in the chain |
+| Every answer backend fails | Hands off to Claude Code |
+| Claude Code itself isn't installed | Prints your prompt so it's never lost |
+| The prompt is trivially short | Skips optimization entirely (like `--no-route`) |
+
+## Privacy
+
+- **Prompt content is never logged.** Not in stats, not in the routing log.
+- `--stats` stores three counters in a local file. That's it.
+- The opt-in routing log (`logging.routingLog: true`) records timestamps, targets, and confidence flags — useful for tuning thresholds, still content-free.
+- Conversation memory (`-c`) lives in one local JSON file you can delete anytime with `--clear-session`.
+
+## Development
+
+```bash
+git clone https://github.com/PTB-0/prompt-router
+cd prompt-router
+pnpm install
+pnpm test        # vitest — the routing logic is fully unit-tested
+pnpm typecheck   # TypeScript strict, no `any`
+pnpm dev "your prompt"
+```
+
+Built test-first: every routing rule in `src/route.ts` and every heuristic in `src/heuristics.ts` is pinned by a test in `test/`. CI runs the suite on Linux and Windows, Node 18 and 22.
+
+## Roadmap
+
+- [ ] `prompt-router init` — interactive setup wizard
+- [ ] npm publish with GitHub Actions provenance
+- [ ] Reuse [prompt-op](https://github.com/PTB-0/prompt-op)'s optimizer as a library dependency
+- [ ] Per-backend capability manifests
+
+## Related
+
+- [prompt-op](https://github.com/PTB-0/prompt-op) — the sibling tool this grew out of: prompt optimization for Claude Code, without routing.
+
+## License
+
+[MIT](LICENSE) © 2026 Ege

package/dist/classify.js

@@ -0,0 +1,68 @@
+import { chatCompletion, withModelFallback } from "./llm.js";
+export const CLASSIFY_SYSTEM_PROMPT = `You are the routing brain of prompt-router, a CLI that optimizes a prompt and routes it to the right AI backend.
+
+Rewrite the user's prompt to be precise and actionable while preserving their intent exactly — do not add features they did not ask for. If the prompt is already specific, keep it unchanged. Write the rewritten prompt in the same language the user used.
+
+Then classify it:
+- "code": writing, fixing, refactoring, reviewing, or explaining project code; anything meant for a coding agent.
+- "simple-qa": a short factual or everyday question answerable in a few sentences.
+- "deep-qa": a broad, open-ended, or multi-part question that needs a long, reasoned answer.
+
+complexity (0 to 1): for "code", how large or architectural the task is (0 = one-line fix, 1 = multi-file production feature). For questions, how much reasoning the answer needs.
+confidence (0 to 1): how sure you are about the category.
+
+Respond with ONLY this JSON object — no markdown fence, no commentary:
+{"optimized_prompt": "...", "category": "code" | "simple-qa" | "deep-qa", "complexity": 0.0, "confidence": 0.0}`;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toScore(value) {
+    const num = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
+    if (Number.isNaN(num))
+        return null;
+    return Math.min(1, Math.max(0, num));
+}
+function isCategory(value) {
+    return value === "code" || value === "simple-qa" || value === "deep-qa";
+}
+export function parseClassification(raw) {
+    const start = raw.indexOf("{");
+    const end = raw.lastIndexOf("}");
+    if (start === -1 || end <= start)
+        return null;
+    let data;
+    try {
+        data = JSON.parse(raw.slice(start, end + 1));
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(data))
+        return null;
+    const optimizedPrompt = typeof data["optimized_prompt"] === "string" ? data["optimized_prompt"].trim() : "";
+    const complexity = toScore(data["complexity"]);
+    const confidence = toScore(data["confidence"]);
+    const category = data["category"];
+    if (!optimizedPrompt || complexity === null || confidence === null || !isCategory(category)) {
+        return null;
+    }
+    return { optimizedPrompt, category, complexity, confidence };
+}
+export async function classify(prompt, config) {
+    if (!config.openrouter.apiKey)
+        return null;
+    return withModelFallback(config.openrouter.classifierModels, async (model) => {
+        const raw = await chatCompletion({
+            baseUrl: config.openrouter.baseUrl,
+            apiKey: config.openrouter.apiKey,
+            model,
+            messages: [
+                { role: "system", content: CLASSIFY_SYSTEM_PROMPT },
+                { role: "user", content: prompt },
+            ],
+            maxTokens: 1024,
+            timeoutMs: config.timeoutMs,
+        });
+        return raw ? parseClassification(raw) : null;
+    });
+}

package/dist/config.js

@@ -0,0 +1,112 @@
+import { config as loadDotenv } from "dotenv";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+const DEFAULTS = {
+    openrouter: {
+        baseUrl: "https://openrouter.ai/api/v1",
+        apiKey: undefined,
+        classifierModels: [
+            "meta-llama/llama-3.1-8b-instruct:free",
+            "google/gemma-2-9b-it:free",
+            "mistralai/mistral-7b-instruct:free",
+        ],
+        answerModels: [
+            "meta-llama/llama-3.3-70b-instruct:free",
+            "deepseek/deepseek-chat:free",
+            "google/gemma-2-9b-it:free",
+        ],
+        planModels: [
+            "meta-llama/llama-3.3-70b-instruct:free",
+            "deepseek/deepseek-chat:free",
+            "meta-llama/llama-3.1-8b-instruct:free",
+        ],
+    },
+    local: {
+        baseUrl: "http://localhost:1234/v1",
+        model: "gemma-4-12b-qat",
+        autoStart: true,
+        enabled: true,
+    },
+    thresholds: {
+        confidence: 0.6,
+        planComplexity: 0.7,
+    },
+    session: {
+        maxMessages: 12,
+    },
+    logging: {
+        routingLog: false,
+    },
+    timeoutMs: 8000,
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pickString(value, fallback) {
+    return typeof value === "string" && value ? value : fallback;
+}
+function pickBoolean(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function pickPositive(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function pickScore(value, fallback) {
+    return typeof value === "number" && value >= 0 && value <= 1 ? value : fallback;
+}
+function pickStringArray(value, fallback) {
+    return Array.isArray(value) && value.length > 0 && value.every((x) => typeof x === "string")
+        ? value
+        : fallback;
+}
+export function resolveConfig(fileCfg, env) {
+    const cfg = structuredClone(DEFAULTS);
+    const file = isRecord(fileCfg) ? fileCfg : {};
+    const or = isRecord(file["openrouter"]) ? file["openrouter"] : {};
+    cfg.openrouter.baseUrl = pickString(or["baseUrl"], cfg.openrouter.baseUrl);
+    cfg.openrouter.classifierModels = pickStringArray(or["classifierModels"], cfg.openrouter.classifierModels);
+    cfg.openrouter.answerModels = pickStringArray(or["answerModels"], cfg.openrouter.answerModels);
+    cfg.openrouter.planModels = pickStringArray(or["planModels"], cfg.openrouter.planModels);
+    const local = isRecord(file["local"]) ? file["local"] : {};
+    cfg.local.baseUrl = pickString(local["baseUrl"], cfg.local.baseUrl);
+    cfg.local.model = pickString(local["model"], cfg.local.model);
+    cfg.local.autoStart = pickBoolean(local["autoStart"], cfg.local.autoStart);
+    cfg.local.enabled = pickBoolean(local["enabled"], cfg.local.enabled);
+    const thresholds = isRecord(file["thresholds"]) ? file["thresholds"] : {};
+    cfg.thresholds.confidence = pickScore(thresholds["confidence"], cfg.thresholds.confidence);
+    cfg.thresholds.planComplexity = pickScore(thresholds["planComplexity"], cfg.thresholds.planComplexity);
+    const session = isRecord(file["session"]) ? file["session"] : {};
+    cfg.session.maxMessages = pickPositive(session["maxMessages"], cfg.session.maxMessages);
+    const logging = isRecord(file["logging"]) ? file["logging"] : {};
+    cfg.logging.routingLog = pickBoolean(logging["routingLog"], cfg.logging.routingLog);
+    cfg.timeoutMs = pickPositive(file["timeoutMs"], cfg.timeoutMs);
+    // Environment overrides beat the file.
+    if (env.OPENROUTER_API_KEY)
+        cfg.openrouter.apiKey = env.OPENROUTER_API_KEY;
+    if (env.PROMPT_ROUTER_LOCAL_URL)
+        cfg.local.baseUrl = env.PROMPT_ROUTER_LOCAL_URL;
+    if (env.PROMPT_ROUTER_LOCAL_MODEL)
+        cfg.local.model = env.PROMPT_ROUTER_LOCAL_MODEL;
+    if (env.PROMPT_ROUTER_TIMEOUT) {
+        cfg.timeoutMs = pickPositive(Number.parseInt(env.PROMPT_ROUTER_TIMEOUT, 10), cfg.timeoutMs);
+    }
+    return cfg;
+}
+export function configDir() {
+    return process.env.PROMPT_ROUTER_DIR ?? path.join(os.homedir(), ".config", "prompt-router");
+}
+export function loadConfig() {
+    const dir = configDir();
+    // Global install reads ~/.config/prompt-router/.env first; cwd/.env covers local dev.
+    loadDotenv({ path: path.join(dir, ".env") });
+    loadDotenv();
+    let fileCfg;
+    try {
+        fileCfg = JSON.parse(fs.readFileSync(path.join(dir, "config.json"), "utf8"));
+    }
+    catch {
+        fileCfg = undefined;
+    }
+    return resolveConfig(fileCfg, process.env);
+}

package/dist/heuristics.js

@@ -0,0 +1,19 @@
+const CODE_VERBS = /\b(fix|implement|refactor|debug|rewrite|write|add|create|build|install|configure|deploy|migrate|optimi[sz]e|rename|remove|update)\b/i;
+const CODE_VERBS_TR = /(düzelt|yeniden yaz|ekle|oluştur|kur|geliştir|uygula|değiştir|kaldır|güncelle|derle|düzenle)/i;
+const CODE_ARTIFACTS = /(\.[a-z]{1,4}\b|\bfunction\b|\bclass\b|\bbug\b|\berror\b|\bexception\b|\bapi\b|\bendpoint\b|\bdatabase\b|\bcomponent\b|\brepo\b|\bcommit\b|```|\bstack trace\b|\bhata\b|\bfonksiyon\b|\bveritabanı\b|\bkod\b)/i;
+const ERROR_TOKENS = /\w+(error|exception)\b/i;
+const MAX_SIMPLE_QA_WORDS = 12;
+export function heuristicCategory(prompt, ctx) {
+    const text = prompt.trim();
+    if (!text)
+        return null;
+    const verb = CODE_VERBS.test(text) || CODE_VERBS_TR.test(text);
+    const artifact = CODE_ARTIFACTS.test(text) || ERROR_TOKENS.test(text);
+    if (verb && (artifact || ctx.inCodeProject))
+        return "code";
+    const wordCount = text.split(/\s+/).length;
+    if (/\?\s*$/.test(text) && wordCount <= MAX_SIMPLE_QA_WORDS && !verb && !artifact) {
+        return "simple-qa";
+    }
+    return null;
+}

package/dist/index.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import pc from "picocolors";
+import { classify } from "./classify.js";
+import { configDir, loadConfig } from "./config.js";
+import { heuristicCategory } from "./heuristics.js";
+import { streamChat, withModelFallback } from "./llm.js";
+import { ensureLocalServer } from "./local.js";
+import { attachPlan, generatePlan } from "./plan.js";
+import { decideRoute } from "./route.js";
+import { appendToSession, clearSession, loadSession } from "./session.js";
+import { formatStats, loadStats, recordRoute } from "./stats.js";
+import { askPlanChoice, askRouteChoice, showError, showPassThrough, showPlan, showRouting, startSpinner, TARGET_LABELS, } from "./ui.js";
+const MIN_PROMPT_LENGTH = 10;
+const ANSWER_TIMEOUT_FLOOR_MS = 30_000;
+const USAGE = `Usage: prompt-router "your prompt"
+  -c, --continue       carry the previous conversation into this one
+      --to <target>    force a backend: claude | local | openrouter
+      --no-route       skip optimization and routing, go straight to Claude Code
+      --stats          show routing statistics
+      --clear-session  forget the stored conversation
+`;
+function parseArgs(argv) {
+    const args = {
+        prompt: "",
+        continueSession: false,
+        noRoute: false,
+        forceTarget: null,
+        showStats: false,
+        clear: false,
+    };
+    const parts = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        if (arg === "-c" || arg === "--continue")
+            args.continueSession = true;
+        else if (arg === "--no-route")
+            args.noRoute = true;
+        else if (arg === "--stats")
+            args.showStats = true;
+        else if (arg === "--clear-session")
+            args.clear = true;
+        else if (arg === "--to") {
+            const target = argv[++i];
+            if (target === "claude" || target === "local" || target === "openrouter") {
+                args.forceTarget = target;
+            }
+            else {
+                process.stderr.write("prompt-router: --to expects claude | local | openrouter\n");
+                process.exit(1);
+            }
+        }
+        else
+            parts.push(arg);
+    }
+    args.prompt = parts.join(" ").trim();
+    return args;
+}
+const PROJECT_MARKERS = [
+    ".git",
+    "package.json",
+    "pnpm-workspace.yaml",
+    "Cargo.toml",
+    "go.mod",
+    "pyproject.toml",
+    "requirements.txt",
+    "build.gradle",
+    "pom.xml",
+];
+function detectCodeProject() {
+    return PROJECT_MARKERS.some((marker) => fs.existsSync(path.join(process.cwd(), marker)));
+}
+function routeDetail(target, config) {
+    if (target === "local")
+        return `${TARGET_LABELS.local} (${config.local.model})`;
+    if (target === "openrouter") {
+        return `${TARGET_LABELS.openrouter} (${config.openrouter.answerModels[0] ?? "free model"})`;
+    }
+    return TARGET_LABELS.claude;
+}
+function runClaude(text, continueSession) {
+    const claudeArgs = continueSession ? ["-c", text] : [text];
+    const result = spawnSync("claude", claudeArgs, {
+        stdio: "inherit",
+        shell: process.platform === "win32",
+    });
+    if (result.error) {
+        showError(`failed to run claude: ${result.error.message}`);
+        process.stderr.write("Your prompt, so it is not lost:\n\n");
+        process.stdout.write(text + "\n");
+        process.exit(1);
+    }
+    process.exit(result.status ?? 1);
+}
+function openInEditor(content) {
+    const tmpFile = path.join(os.tmpdir(), `prompt-router-${Date.now()}.txt`);
+    fs.writeFileSync(tmpFile, content, "utf8");
+    const editor = process.env.EDITOR ?? (process.platform === "win32" ? "notepad" : "vi");
+    spawnSync(editor, [tmpFile], { stdio: "inherit", shell: process.platform === "win32" });
+    const edited = fs.readFileSync(tmpFile, "utf8").trim();
+    fs.unlinkSync(tmpFile);
+    return edited || content;
+}
+function logRouting(config, decision) {
+    // Opt-in and content-free by design: categories and targets only, never the prompt.
+    if (!config.logging.routingLog)
+        return;
+    try {
+        const dir = configDir();
+        fs.mkdirSync(dir, { recursive: true });
+        fs.appendFileSync(path.join(dir, "routing-log.jsonl"), JSON.stringify({
+            ts: new Date().toISOString(),
+            target: decision.target,
+            planFirst: decision.planFirst,
+            uncertain: decision.uncertain,
+        }) + "\n", "utf8");
+    }
+    catch {
+        // logging must never break routing
+    }
+}
+async function runClaudeRoute(prompt, decision, config, args) {
+    let finalPrompt = prompt;
+    if (decision.planFirst) {
+        const stopSpinner = startSpinner("Drafting plan...");
+        const plan = await generatePlan(prompt, config);
+        stopSpinner();
+        if (plan) {
+            showPlan(plan);
+            const planChoice = await askPlanChoice();
+            process.stderr.write("\n");
+            if (planChoice === "accept")
+                finalPrompt = attachPlan(prompt, plan);
+            else if (planChoice === "edit")
+                finalPrompt = attachPlan(prompt, openInEditor(plan));
+            // "skip" keeps the prompt as-is
+        }
+        else {
+            showPassThrough("plan generation unavailable — sending the prompt without a plan");
+        }
+    }
+    runClaude(finalPrompt, args.continueSession);
+}
+async function runChatRoute(prompt, decision, config, args) {
+    const dir = configDir();
+    const history = args.continueSession ? loadSession(dir) : [];
+    const messages = [
+        ...history.map((m) => ({ role: m.role, content: m.content })),
+        { role: "user", content: prompt },
+    ];
+    const timeoutMs = Math.max(config.timeoutMs, ANSWER_TIMEOUT_FLOOR_MS);
+    const writeDelta = (text) => {
+        process.stdout.write(text);
+    };
+    let answer = null;
+    if (decision.target === "local") {
+        const stopSpinner = startSpinner("Reaching local model...");
+        const up = await ensureLocalServer(config);
+        stopSpinner();
+        if (up) {
+            answer = await streamChat({ baseUrl: config.local.baseUrl, model: config.local.model, messages, timeoutMs }, writeDelta);
+        }
+        if (answer === null) {
+            showPassThrough("local model unavailable — falling back to OpenRouter");
+        }
+    }
+    if (answer === null) {
+        if (!config.openrouter.apiKey) {
+            showPassThrough("no OPENROUTER_API_KEY — handing off to Claude Code");
+            runClaude(prompt, args.continueSession);
+        }
+        answer = await withModelFallback(config.openrouter.answerModels, async (model) => {
+            let wrote = false;
+            const result = await streamChat({
+                baseUrl: config.openrouter.baseUrl,
+                apiKey: config.openrouter.apiKey,
+                model,
+                messages,
+                timeoutMs,
+            }, (text) => {
+                wrote = true;
+                writeDelta(text);
+            });
+            if (result === null && wrote) {
+                process.stdout.write(pc.dim("\n[stream interrupted — retrying with another model]\n"));
+            }
+            return result;
+        });
+    }
+    if (answer === null) {
+        showPassThrough("all answer backends failed — handing off to Claude Code");
+        runClaude(prompt, args.continueSession);
+    }
+    process.stdout.write("\n");
+    appendToSession(dir, [
+        { role: "user", content: prompt },
+        { role: "assistant", content: answer },
+    ], config.session.maxMessages);
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const dir = configDir();
+    if (args.showStats) {
+        process.stdout.write(formatStats(loadStats(dir)) + "\n");
+        return;
+    }
+    if (args.clear) {
+        clearSession(dir);
+        process.stderr.write("prompt-router: session cleared.\n");
+        return;
+    }
+    if (!args.prompt) {
+        process.stderr.write(USAGE);
+        process.exit(1);
+    }
+    const config = loadConfig();
+    if (args.noRoute || args.prompt.length < MIN_PROMPT_LENGTH) {
+        runClaude(args.prompt, args.continueSession);
+    }
+    const heuristic = heuristicCategory(args.prompt, { inCodeProject: detectCodeProject() });
+    const stopSpinner = startSpinner("Optimizing & routing...");
+    const cls = await classify(args.prompt, config);
+    stopSpinner();
+    if (!cls)
+        showPassThrough("optimizer unavailable — using the original prompt");
+    let decision = args.forceTarget
+        ? { target: args.forceTarget, planFirst: false, uncertain: false }
+        : decideRoute(cls, heuristic, {
+            confidenceThreshold: config.thresholds.confidence,
+            planComplexityThreshold: config.thresholds.planComplexity,
+            localAvailable: config.local.enabled,
+        });
+    let finalPrompt = cls?.optimizedPrompt ?? args.prompt;
+    if (!args.forceTarget) {
+        showRouting(args.prompt, finalPrompt, decision, routeDetail(decision.target, config), cls);
+        const choice = await askRouteChoice();
+        process.stderr.write("\n");
+        if (choice.action === "reject")
+            finalPrompt = args.prompt;
+        else if (choice.action === "edit")
+            finalPrompt = openInEditor(finalPrompt);
+        if (choice.overrideTarget) {
+            decision = {
+                ...decision,
+                target: choice.overrideTarget,
+                planFirst: choice.overrideTarget === "claude" ? decision.planFirst : false,
+            };
+        }
+    }
+    recordRoute(dir, decision.target);
+    logRouting(config, decision);
+    if (decision.target === "claude") {
+        await runClaudeRoute(finalPrompt, decision, config, args);
+    }
+    else {
+        await runChatRoute(finalPrompt, decision, config, args);
+    }
+}
+main().catch((err) => {
+    showError(err instanceof Error ? err.message : "unexpected error");
+    process.exit(1);
+});

package/dist/llm.js

@@ -0,0 +1,153 @@
+function buildHeaders(apiKey) {
+    const headers = {
+        "Content-Type": "application/json",
+        "HTTP-Referer": "https://github.com/PTB-0/prompt-router",
+        "X-Title": "prompt-router",
+    };
+    if (apiKey)
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    return headers;
+}
+function messageContent(data) {
+    if (typeof data !== "object" || data === null)
+        return null;
+    const choices = data["choices"];
+    if (!Array.isArray(choices) || choices.length === 0)
+        return null;
+    const first = choices[0];
+    if (typeof first !== "object" || first === null)
+        return null;
+    const message = first["message"];
+    if (typeof message !== "object" || message === null)
+        return null;
+    const content = message["content"];
+    return typeof content === "string" ? content.trim() : null;
+}
+function deltaContent(data) {
+    if (typeof data !== "object" || data === null)
+        return null;
+    const choices = data["choices"];
+    if (!Array.isArray(choices) || choices.length === 0)
+        return null;
+    const first = choices[0];
+    if (typeof first !== "object" || first === null)
+        return null;
+    const delta = first["delta"];
+    if (typeof delta !== "object" || delta === null)
+        return null;
+    const content = delta["content"];
+    return typeof content === "string" ? content : null;
+}
+export async function withModelFallback(models, attempt) {
+    for (const model of models) {
+        try {
+            const result = await attempt(model);
+            if (result !== null)
+                return result;
+        }
+        catch {
+            // failed model — try the next one
+        }
+    }
+    return null;
+}
+export function extractSseDeltas(buffer) {
+    const deltas = [];
+    let rest = buffer;
+    for (;;) {
+        const separator = rest.indexOf("\n\n");
+        if (separator === -1)
+            break;
+        const event = rest.slice(0, separator);
+        rest = rest.slice(separator + 2);
+        for (const line of event.split("\n")) {
+            if (!line.startsWith("data:"))
+                continue;
+            const payload = line.slice(5).trim();
+            if (!payload || payload === "[DONE]")
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(payload);
+            }
+            catch {
+                continue;
+            }
+            const delta = deltaContent(parsed);
+            if (delta)
+                deltas.push(delta);
+        }
+    }
+    return { deltas, rest };
+}
+export async function chatCompletion(req) {
+    const fetchImpl = req.fetchImpl ?? fetch;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), req.timeoutMs);
+    try {
+        const response = await fetchImpl(`${req.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: buildHeaders(req.apiKey),
+            body: JSON.stringify({
+                model: req.model,
+                messages: req.messages,
+                max_tokens: req.maxTokens ?? 1024,
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return null;
+        return messageContent(await response.json());
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function streamChat(req, onDelta) {
+    const fetchImpl = req.fetchImpl ?? fetch;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), req.timeoutMs);
+    try {
+        const response = await fetchImpl(`${req.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: buildHeaders(req.apiKey),
+            body: JSON.stringify({
+                model: req.model,
+                messages: req.messages,
+                max_tokens: req.maxTokens ?? 4096,
+                stream: true,
+            }),
+            signal: controller.signal,
+        });
+        // The timeout guards the connection; once headers arrive the stream may run long.
+        clearTimeout(timer);
+        if (!response.ok || !response.body)
+            return null;
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let full = "";
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const { deltas, rest } = extractSseDeltas(buffer);
+            buffer = rest;
+            for (const delta of deltas) {
+                full += delta;
+                onDelta(delta);
+            }
+        }
+        return full || null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/local.js

@@ -0,0 +1,48 @@
+import { spawn } from "child_process";
+const PROBE_TIMEOUT_MS = 1500;
+const START_POLL_ATTEMPTS = 6;
+const START_POLL_INTERVAL_MS = 1000;
+export async function isServerUp(baseUrl, timeoutMs, fetchImpl = fetch) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetchImpl(`${baseUrl}/models`, { signal: controller.signal });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function ensureLocalServer(config) {
+    if (!config.local.enabled)
+        return false;
+    if (await isServerUp(config.local.baseUrl, PROBE_TIMEOUT_MS))
+        return true;
+    if (!config.local.autoStart)
+        return false;
+    // LM Studio ships the `lms` CLI; `server start` is a no-op when already running.
+    try {
+        const child = spawn("lms", ["server", "start"], {
+            shell: process.platform === "win32",
+            stdio: "ignore",
+            detached: true,
+        });
+        child.on("error", () => undefined);
+        child.unref();
+    }
+    catch {
+        return false;
+    }
+    for (let attempt = 0; attempt < START_POLL_ATTEMPTS; attempt++) {
+        await delay(START_POLL_INTERVAL_MS);
+        if (await isServerUp(config.local.baseUrl, PROBE_TIMEOUT_MS))
+            return true;
+    }
+    return false;
+}

package/dist/plan.js

@@ -0,0 +1,28 @@
+import { chatCompletion, withModelFallback } from "./llm.js";
+const PLAN_SYSTEM_PROMPT = `You are a senior software architect. The user's prompt will be executed by Claude Code, an agentic coding assistant. Write a concise implementation plan it can follow.
+
+Rules:
+- Output ONLY the plan, as a numbered list of concrete steps.
+- Name the files, modules, and commands involved when they can be inferred.
+- Include a final verification step (tests, typecheck, or a manual check).
+- Stay within the user's intent — do not invent extra features.
+- Write the plan in the same language the user used.`;
+const PLAN_TIMEOUT_FLOOR_MS = 20_000;
+export async function generatePlan(prompt, config) {
+    if (!config.openrouter.apiKey)
+        return null;
+    return withModelFallback(config.openrouter.planModels, (model) => chatCompletion({
+        baseUrl: config.openrouter.baseUrl,
+        apiKey: config.openrouter.apiKey,
+        model,
+        messages: [
+            { role: "system", content: PLAN_SYSTEM_PROMPT },
+            { role: "user", content: prompt },
+        ],
+        maxTokens: 2048,
+        timeoutMs: Math.max(config.timeoutMs, PLAN_TIMEOUT_FLOOR_MS),
+    }));
+}
+export function attachPlan(prompt, plan) {
+    return `${prompt}\n\n## PLAN (prepared by prompt-router, approved by the user)\nFollow this plan unless the code contradicts it:\n\n${plan}`;
+}

package/dist/route.js

@@ -0,0 +1,23 @@
+export function decideRoute(cls, heuristic, opts) {
+    if (!cls && !heuristic) {
+        // No signal at all: send it to the strongest backend rather than risk a weak answer.
+        return { target: "claude", planFirst: false, uncertain: true };
+    }
+    // Misrouting a code task to a small model is far worse than over-serving a
+    // question, so a code verdict from either signal wins.
+    const category = heuristic === "code" || cls?.category === "code"
+        ? "code"
+        : (cls?.category ?? heuristic ?? "code");
+    const uncertain = cls !== null && cls.confidence < opts.confidenceThreshold;
+    if (category === "code") {
+        return {
+            target: "claude",
+            planFirst: cls !== null && cls.complexity >= opts.planComplexityThreshold,
+            uncertain,
+        };
+    }
+    if (category === "simple-qa" && opts.localAvailable) {
+        return { target: "local", planFirst: false, uncertain };
+    }
+    return { target: "openrouter", planFirst: false, uncertain };
+}

package/dist/session.js

@@ -0,0 +1,31 @@
+import * as fs from "fs";
+import * as path from "path";
+function sessionFile(dir) {
+    return path.join(dir, "session.json");
+}
+function isMessage(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const record = value;
+    return ((record["role"] === "user" || record["role"] === "assistant") &&
+        typeof record["content"] === "string");
+}
+export function loadSession(dir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(sessionFile(dir), "utf8"));
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter(isMessage);
+    }
+    catch {
+        return [];
+    }
+}
+export function appendToSession(dir, messages, max) {
+    const history = [...loadSession(dir), ...messages].slice(-max);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(sessionFile(dir), JSON.stringify(history, null, 2), "utf8");
+}
+export function clearSession(dir) {
+    fs.rmSync(sessionFile(dir), { force: true });
+}

package/dist/stats.js

@@ -0,0 +1,42 @@
+import * as fs from "fs";
+import * as path from "path";
+function statsFile(dir) {
+    return path.join(dir, "stats.json");
+}
+function toCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+export function loadStats(dir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(statsFile(dir), "utf8"));
+        if (typeof parsed !== "object" || parsed === null) {
+            return { claude: 0, local: 0, openrouter: 0 };
+        }
+        const record = parsed;
+        return {
+            claude: toCount(record["claude"]),
+            local: toCount(record["local"]),
+            openrouter: toCount(record["openrouter"]),
+        };
+    }
+    catch {
+        return { claude: 0, local: 0, openrouter: 0 };
+    }
+}
+export function recordRoute(dir, target) {
+    const stats = loadStats(dir);
+    stats[target] += 1;
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(statsFile(dir), JSON.stringify(stats, null, 2), "utf8");
+}
+export function formatStats(stats) {
+    const diverted = stats.local + stats.openrouter;
+    const total = diverted + stats.claude;
+    return [
+        "prompt-router stats",
+        `  claude:      ${stats.claude}`,
+        `  local:       ${stats.local}`,
+        `  openrouter:  ${stats.openrouter}`,
+        `  diverted from claude: ${diverted} of ${total} prompts`,
+    ].join("\n");
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui.js

@@ -0,0 +1,140 @@
+import * as readline from "readline";
+import pc from "picocolors";
+const WIDTH = Math.min(process.stderr.columns ?? 80, 100);
+const LINE = "─".repeat(WIDTH);
+const TIMEOUT_MS = 15_000;
+export const TARGET_LABELS = {
+    claude: "Claude Code",
+    local: "local model",
+    openrouter: "OpenRouter",
+};
+export function showRouting(original, optimized, decision, detail, cls) {
+    const err = process.stderr;
+    err.write("\n" + pc.dim(LINE) + "\n");
+    err.write(pc.bold("  prompt-router") + pc.dim(" — optimized & routed\n"));
+    err.write(pc.dim(LINE) + "\n\n");
+    err.write(pc.dim("  ORIGINAL\n"));
+    err.write(pc.dim("  " + original.replace(/\n/g, "\n  ")) + "\n\n");
+    if (optimized !== original) {
+        err.write(pc.green(pc.bold("  OPTIMIZED\n")));
+        err.write(pc.green("  " + optimized.replace(/\n/g, "\n  ")) + "\n\n");
+    }
+    const planNote = decision.planFirst ? pc.cyan(" · plan-first") : "";
+    const uncertainNote = decision.uncertain ? pc.yellow(" · low confidence") : "";
+    err.write(pc.bold(`  ROUTE → ${detail}`) + planNote + uncertainNote + "\n");
+    if (cls) {
+        err.write(pc.dim(`  (${cls.category}, complexity ${cls.complexity.toFixed(1)}, confidence ${cls.confidence.toFixed(1)})`) + "\n");
+    }
+    err.write("\n" + pc.dim(LINE) + "\n");
+}
+export function askRouteChoice() {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+        process.stderr.write("  " +
+            pc.green("[Y]") +
+            pc.dim("es  ") +
+            pc.red("[n]") +
+            pc.dim("o, original  ") +
+            pc.cyan("[e]") +
+            pc.dim("dit  ") +
+            pc.magenta("[c]") +
+            pc.dim("laude  ") +
+            pc.magenta("[l]") +
+            pc.dim("ocal  ") +
+            pc.magenta("[o]") +
+            pc.dim("penrouter  ") +
+            pc.dim(`(${TIMEOUT_MS / 1000}s timeout → Y): `));
+        let settled = false;
+        const finish = (choice) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            rl.close();
+            resolve(choice);
+        };
+        const timer = setTimeout(() => {
+            process.stderr.write(pc.dim("Y\n"));
+            finish({ action: "accept" });
+        }, TIMEOUT_MS);
+        rl.once("close", () => finish({ action: "accept" }));
+        rl.once("line", (line) => {
+            const answer = line.trim().toLowerCase();
+            if (answer === "n" || answer === "no")
+                finish({ action: "reject" });
+            else if (answer === "e" || answer === "edit")
+                finish({ action: "edit" });
+            else if (answer === "c")
+                finish({ action: "accept", overrideTarget: "claude" });
+            else if (answer === "l")
+                finish({ action: "accept", overrideTarget: "local" });
+            else if (answer === "o")
+                finish({ action: "accept", overrideTarget: "openrouter" });
+            else
+                finish({ action: "accept" });
+        });
+    });
+}
+export function showPlan(plan) {
+    const err = process.stderr;
+    err.write("\n" + pc.dim(LINE) + "\n");
+    err.write(pc.bold("  PLAN") + pc.dim(" — will be attached to the prompt\n"));
+    err.write(pc.dim(LINE) + "\n\n");
+    err.write(pc.cyan("  " + plan.replace(/\n/g, "\n  ")) + "\n\n");
+    err.write(pc.dim(LINE) + "\n");
+}
+export function askPlanChoice() {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+        process.stderr.write("  " +
+            pc.green("[Y]") +
+            pc.dim("es, attach  ") +
+            pc.red("[n]") +
+            pc.dim("o, skip plan  ") +
+            pc.cyan("[e]") +
+            pc.dim("dit  ") +
+            pc.dim(`(${TIMEOUT_MS / 1000}s timeout → Y): `));
+        let settled = false;
+        const finish = (choice) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            rl.close();
+            resolve(choice);
+        };
+        const timer = setTimeout(() => {
+            process.stderr.write(pc.dim("Y\n"));
+            finish("accept");
+        }, TIMEOUT_MS);
+        rl.once("close", () => finish("accept"));
+        rl.once("line", (line) => {
+            const answer = line.trim().toLowerCase();
+            if (answer === "n" || answer === "no")
+                finish("skip");
+            else if (answer === "e" || answer === "edit")
+                finish("edit");
+            else
+                finish("accept");
+        });
+    });
+}
+export function showPassThrough(reason) {
+    process.stderr.write(pc.dim(`prompt-router: ${reason}.\n`));
+}
+export function showError(message) {
+    process.stderr.write(pc.yellow(`prompt-router: ${message}\n`));
+}
+export function startSpinner(label) {
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    let i = 0;
+    process.stderr.write(pc.dim(`  ${label}`));
+    const interval = setInterval(() => {
+        process.stderr.write("\r" + pc.dim(`  ${frames[i]} ${label}`));
+        i = (i + 1) % frames.length;
+    }, 80);
+    return () => {
+        clearInterval(interval);
+        process.stderr.write("\r" + " ".repeat(label.length + 6) + "\r");
+    };
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "prompt-router",
+  "version": "0.1.0",
+  "description": "Route your prompts to the right AI: coding tasks to Claude Code, simple questions to your local model, deep questions to OpenRouter — with prompt optimization built in.",
+  "type": "module",
+  "bin": {
+    "prompt-router": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "pnpm typecheck && pnpm test && pnpm build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.5",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0",
+    "vitest": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "router",
+    "llm",
+    "openrouter",
+    "lm-studio",
+    "prompt",
+    "ai",
+    "cli"
+  ],
+  "license": "MIT",
+  "author": "Ege",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PTB-0/prompt-router"
+  }
+}