@ast-ai-model-router/cli 0.1.1

package/.claude-plugin/plugin.json

@@ -0,0 +1,21 @@
+{
+  "name": "ast-ai-model-router",
+  "version": "0.1.0",
+  "description": "AST-aware Claude and Codex model routing for cost-conscious coding tasks.",
+  "author": {
+    "name": "Faraazuddin Mohammed",
+    "email": "opensource@faraa2m.dev",
+    "url": "https://github.com/faraa2m"
+  },
+  "homepage": "https://github.com/faraa2m/ast-ai-model-router#readme",
+  "repository": "https://github.com/faraa2m/ast-ai-model-router",
+  "license": "MIT",
+  "keywords": [
+    "token-economics",
+    "model-router",
+    "claude-code",
+    "codex",
+    "ast"
+  ],
+  "skills": "./skills/"
+}

package/.codex-plugin/plugin.json

@@ -0,0 +1,41 @@
+{
+  "name": "ast-ai-model-router",
+  "version": "0.1.0",
+  "description": "AST-aware Claude and Codex model routing for cost-conscious coding tasks.",
+  "author": {
+    "name": "Faraazuddin Mohammed",
+    "email": "opensource@faraa2m.dev",
+    "url": "https://github.com/faraa2m"
+  },
+  "homepage": "https://github.com/faraa2m/ast-ai-model-router#readme",
+  "repository": "https://github.com/faraa2m/ast-ai-model-router",
+  "license": "MIT",
+  "keywords": [
+    "token-economics",
+    "model-router",
+    "claude-code",
+    "codex",
+    "ast"
+  ],
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "AST AI Model Router",
+    "shortDescription": "Pick Claude or Codex models from AST and task complexity signals.",
+    "longDescription": "AST AI Model Router analyzes JavaScript, TypeScript, and Python project structure plus the current task to choose an appropriate Claude or Codex model before launch. It is part of a token-economics toolkit for measuring, reducing, and routing LLM spend.",
+    "developerName": "Faraazuddin Mohammed",
+    "category": "Developer Tools",
+    "capabilities": [
+      "Interactive",
+      "Local"
+    ],
+    "websiteURL": "https://github.com/faraa2m/ast-ai-model-router",
+    "privacyPolicyURL": "https://github.com/faraa2m/ast-ai-model-router#privacy",
+    "termsOfServiceURL": "https://github.com/faraa2m/ast-ai-model-router#license",
+    "defaultPrompt": [
+      "Analyze this repo and choose the right Codex model.",
+      "Route this Claude Code task by AST complexity.",
+      "Explain why this coding task needs a stronger model."
+    ],
+    "brandColor": "#2563EB"
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Faraazuddin Mohammed
+
+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,111 @@
+# AST AI Model Router
+
+AST-aware model selection for Claude Code and Codex. It inspects the current task, JavaScript/TypeScript ASTs, Python ASTs, and repo shape, then launches the coding agent with a dynamically chosen model.
+
+This project is part of the [`faraa2m`](https://github.com/faraa2m) token economics stack:
+
+- [`tokenometer`](https://github.com/faraa2m/tokenometer) measures tokens, USD cost, latency, and CI prompt-cost regressions.
+- [`llm-tokens-atlas`](https://github.com/faraa2m/llm-tokens-atlas) calibrates offline tokenizers against empirical provider counts.
+- [`routerlab`](https://github.com/faraa2m/routerlab) builds cost-quality routing frontiers for LLM APIs.
+- [`promptc`](https://github.com/faraa2m/promptc) compiles prompts through deterministic cost-reduction passes.
+- `ast-ai-model-router` brings that cost-aware routing idea into local coding agents.
+
+## Install
+
+```bash
+npm install -g @ast-ai-model-router/cli
+```
+
+For local development:
+
+```bash
+npm install
+npm link
+```
+
+## Usage
+
+Analyze a task without launching an agent:
+
+```bash
+ast-ai-model-router analyze --agent codex --task "refactor the auth parser and add tests"
+```
+
+Launch Codex with the selected model:
+
+```bash
+ast-ai-model-router run codex --task "fix the failing Python AST tests" -- --cd .
+```
+
+Launch Claude Code with the selected alias:
+
+```bash
+ast-ai-model-router run claude --task "plan a cross-module migration" -- --permission-mode plan
+```
+
+Machine-readable output:
+
+```bash
+ast-ai-model-router analyze --agent codex --task "write docs" --json
+```
+
+## How Routing Works
+
+The router scores four groups of signals:
+
+- Prompt intent: docs, tests, debugging, refactors, architecture, security, migrations.
+- Repo shape: file count, AST file count, package/build/config files.
+- AST complexity: functions, classes, branches, imports, and language mix.
+- Agent model catalog: Codex models are discovered through `codex debug models`; Claude uses dynamic aliases.
+
+Claude targets are intentionally aliases, not dated model names:
+
+- `simple` -> `haiku`
+- `balanced` -> `sonnet`
+- `complex` -> `opus`
+- `planning` -> `opusplan`
+
+Codex targets are selected from the installed Codex model catalog. If discovery fails, the router falls back to configurable defaults in `model-router.config.json`.
+
+## Configuration
+
+Add `model-router.config.json` to a project root:
+
+```json
+{
+  "thresholds": {
+    "simpleMax": 34,
+    "balancedMax": 74
+  },
+  "claude": {
+    "aliases": {
+      "simple": "haiku",
+      "balanced": "sonnet",
+      "complex": "opus",
+      "planning": "opusplan"
+    }
+  },
+  "codex": {
+    "discoveryCommand": "codex debug models"
+  }
+}
+```
+
+## Plugin
+
+This repo includes a Codex/Claude plugin manifest at `.codex-plugin/plugin.json` and a skill under `skills/model-router/`.
+
+Use it directly while developing:
+
+```bash
+claude --plugin-dir .
+codex plugin marketplace add .
+```
+
+## Privacy
+
+The router reads local source files to compute AST complexity and launches the local `claude` or `codex` CLI. It does not add a separate network service. Any model traffic comes from the Claude/Codex CLI you choose to run.
+
+## License
+
+MIT

package/bin/ast-ai-model-router.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { parseArgs } from "node:util";
+import { analyzeTask } from "../lib/analyzer.js";
+import { loadConfig } from "../lib/config.js";
+import { chooseModel } from "../lib/models.js";
+
+const HELP = `ast-ai-model-router
+
+Usage:
+  ast-ai-model-router analyze --agent claude|codex --task "fix auth bug" [--json]
+  ast-ai-model-router run claude --task "refactor parser" -- [extra claude args]
+  ast-ai-model-router run codex --task "write tests" -- [extra codex args]
+
+Options:
+  --agent <agent>      claude or codex for analyze
+  --task <text>        Current task description
+  --cwd <path>         Workspace to inspect, defaults to current directory
+  --json               Emit machine-readable JSON
+  --refresh-models     Refresh Codex model catalog cache
+`;
+
+async function main() {
+  const [command, maybeAgent, ...rest] = process.argv.slice(2);
+  if (!command || command === "--help" || command === "-h") {
+    process.stdout.write(HELP);
+    return;
+  }
+
+  if (command === "analyze") {
+    const { values } = parseArgs({
+      args: [maybeAgent, ...rest].filter(Boolean),
+      options: {
+        agent: { type: "string" },
+        task: { type: "string" },
+        cwd: { type: "string" },
+        json: { type: "boolean" },
+        "refresh-models": { type: "boolean" }
+      }
+    });
+    const agent = assertAgent(values.agent);
+    const result = await route({ agent, task: values.task, cwd: values.cwd, refreshModels: values["refresh-models"] });
+    printResult(result, Boolean(values.json));
+    return;
+  }
+
+  if (command === "run") {
+    const agent = assertAgent(maybeAgent);
+    const split = rest.indexOf("--");
+    const optionArgs = split === -1 ? rest : rest.slice(0, split);
+    const passthrough = split === -1 ? [] : rest.slice(split + 1);
+    const { values } = parseArgs({
+      args: optionArgs,
+      options: {
+        task: { type: "string" },
+        cwd: { type: "string" },
+        "refresh-models": { type: "boolean" }
+      }
+    });
+    const result = await route({ agent, task: values.task, cwd: values.cwd, refreshModels: values["refresh-models"] });
+    const executable = agent === "claude" ? "claude" : "codex";
+    const args = ["--model", result.selectedModel, ...passthrough];
+    process.stderr.write(`[model-router] ${agent}: ${result.selectedModel} (${result.tier}, confidence ${result.confidence.toFixed(2)})\n`);
+    const child = spawn(executable, args, { cwd: result.cwd, stdio: "inherit" });
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        process.kill(process.pid, signal);
+        return;
+      }
+      process.exit(code ?? 1);
+    });
+    child.on("error", (error) => {
+      process.stderr.write(`[model-router] failed to launch ${executable}: ${error.message}\n`);
+      process.exit(1);
+    });
+    return;
+  }
+
+  throw new Error(`Unknown command: ${command}`);
+}
+
+async function route({ agent, task, cwd, refreshModels }) {
+  const config = await loadConfig(cwd ?? process.cwd());
+  const analysis = await analyzeTask({ cwd: cwd ?? process.cwd(), task: task ?? "", config });
+  const model = await chooseModel({ agent, tier: analysis.tier, task: task ?? "", config, refreshModels: Boolean(refreshModels) });
+  return {
+    agent,
+    cwd: analysis.cwd,
+    selectedModel: model.model,
+    tier: analysis.tier,
+    confidence: analysis.confidence,
+    signals: analysis.signals,
+    modelSource: model.source,
+    commandPreview: `${agent} --model ${model.model}`
+  };
+}
+
+function assertAgent(agent) {
+  if (agent === "claude" || agent === "codex") return agent;
+  throw new Error("Expected agent to be 'claude' or 'codex'.");
+}
+
+function printResult(result, asJson) {
+  if (asJson) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`Agent: ${result.agent}\n`);
+  process.stdout.write(`Model: ${result.selectedModel}\n`);
+  process.stdout.write(`Tier: ${result.tier}\n`);
+  process.stdout.write(`Confidence: ${result.confidence.toFixed(2)}\n`);
+  process.stdout.write(`Signals: ${result.signals.map((signal) => `${signal.name}=${signal.value}`).join(", ")}\n`);
+  process.stdout.write(`Run: ${result.commandPreview}\n`);
+}
+
+main().catch((error) => {
+  process.stderr.write(`[model-router] ${error.message}\n`);
+  process.exit(1);
+});

package/lib/analyzer.js

@@ -0,0 +1,113 @@
+import { readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { analyzeJavaScriptFile } from "./parsers/javascript.js";
+import { analyzePythonFile } from "./parsers/python.js";
+
+const IGNORE_DIRS = new Set([".git", "node_modules", "dist", "build", ".next", ".venv", "venv", "__pycache__", "coverage"]);
+const JS_EXTENSIONS = new Set([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"]);
+const PY_EXTENSIONS = new Set([".py"]);
+
+export async function analyzeTask({ cwd, task, config }) {
+  const root = path.resolve(cwd);
+  const files = await collectFiles(root);
+  const astFiles = files.filter((file) => JS_EXTENSIONS.has(path.extname(file)) || PY_EXTENSIONS.has(path.extname(file))).slice(0, 80);
+  const ast = await summarizeAst(astFiles);
+  const prompt = scorePrompt(task);
+  const repo = scoreRepo(files, astFiles);
+  const score = prompt.score + repo.score + ast.score;
+  const tier = tierFor(score, task, config);
+  const signals = [
+    { name: "prompt", value: prompt.score, detail: prompt.matches.join(",") || "none" },
+    { name: "repo", value: repo.score, detail: `${files.length} files, ${astFiles.length} AST files` },
+    { name: "ast", value: ast.score, detail: `${ast.functions} functions, ${ast.classes} classes, ${ast.branches} branches` },
+    { name: "languages", value: ast.languages.size, detail: [...ast.languages].join(",") || "none" }
+  ];
+  return {
+    cwd: root,
+    tier,
+    confidence: confidenceFor(score, tier, config),
+    score,
+    signals
+  };
+}
+
+async function collectFiles(root, relative = "") {
+  let entries;
+  try {
+    entries = await readdir(path.join(root, relative), { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") && entry.name !== ".github") continue;
+    const child = path.join(relative, entry.name);
+    if (entry.isDirectory()) {
+      if (!IGNORE_DIRS.has(entry.name)) files.push(...await collectFiles(root, child));
+      continue;
+    }
+    if (entry.isFile()) files.push(path.join(root, child));
+  }
+  return files;
+}
+
+async function summarizeAst(files) {
+  const total = { score: 0, functions: 0, classes: 0, branches: 0, imports: 0, languages: new Set() };
+  for (const file of files) {
+    const ext = path.extname(file);
+    const summary = PY_EXTENSIONS.has(ext) ? await analyzePythonFile(file) : await analyzeJavaScriptFile(file);
+    if (!summary.ok) continue;
+    total.functions += summary.functions;
+    total.classes += summary.classes;
+    total.branches += summary.branches;
+    total.imports += summary.imports;
+    total.languages.add(summary.language);
+  }
+  total.score = Math.min(45, total.functions * 0.45 + total.classes * 1.5 + total.branches * 0.7 + total.imports * 0.15 + total.languages.size * 4);
+  return total;
+}
+
+function scorePrompt(task) {
+  const text = task.toLowerCase();
+  const patterns = [
+    [/architecture|design|migration|refactor|rewrite|multi-file|cross-module/g, 18],
+    [/security|auth|database|billing|payment|production|deploy/g, 16],
+    [/debug|bug|failing|regression|race|performance/g, 12],
+    [/test|coverage|unit|integration|e2e/g, 8],
+    [/explain|summarize|readme|docs|comment/g, 4]
+  ];
+  const matches = [];
+  let score = 0;
+  for (const [regex, weight] of patterns) {
+    const found = text.match(regex);
+    if (!found) continue;
+    matches.push(...found);
+    score += Math.min(weight, found.length * weight);
+  }
+  if (text.length > 800) score += 10;
+  if (text.length > 1800) score += 10;
+  return { score: Math.min(50, score), matches };
+}
+
+function scoreRepo(files, astFiles) {
+  let score = 0;
+  if (files.length > 100) score += 8;
+  if (files.length > 500) score += 12;
+  if (astFiles.length > 20) score += 8;
+  if (astFiles.length > 60) score += 12;
+  if (files.some((file) => /package\.json|pyproject\.toml|requirements\.txt|Dockerfile|\.github\/workflows/.test(file))) score += 8;
+  return { score: Math.min(35, score) };
+}
+
+function tierFor(score, task, config) {
+  if (/plan|architecture|migration|strategy/i.test(task) && score >= config.thresholds.simpleMax) return "planning";
+  if (score <= config.thresholds.simpleMax) return "simple";
+  if (score <= config.thresholds.balancedMax) return "balanced";
+  return "complex";
+}
+
+function confidenceFor(score, tier, config) {
+  const target = tier === "simple" ? config.thresholds.simpleMax : tier === "balanced" ? config.thresholds.balancedMax : config.thresholds.balancedMax + 30;
+  const distance = Math.min(40, Math.abs(score - target));
+  return Math.max(0.55, Math.min(0.95, 0.95 - (40 - distance) / 120));
+}

package/lib/config.js

@@ -0,0 +1,57 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+export const DEFAULT_CONFIG = {
+  thresholds: {
+    simpleMax: 34,
+    balancedMax: 74
+  },
+  claude: {
+    aliases: {
+      simple: "haiku",
+      balanced: "sonnet",
+      complex: "opus",
+      planning: "opusplan"
+    }
+  },
+  codex: {
+    discoveryCommand: "codex debug models",
+    fallbackModels: {
+      simple: "gpt-5.4-mini",
+      balanced: "gpt-5.4",
+      complex: "gpt-5.5",
+      planning: "gpt-5.5"
+    }
+  },
+  overrides: []
+};
+
+export async function loadConfig(cwd) {
+  const configPath = path.join(cwd, "model-router.config.json");
+  try {
+    const raw = await readFile(configPath, "utf8");
+    return mergeConfig(DEFAULT_CONFIG, JSON.parse(raw));
+  } catch (error) {
+    if (error.code === "ENOENT") return DEFAULT_CONFIG;
+    throw error;
+  }
+}
+
+function mergeConfig(base, override) {
+  return {
+    ...base,
+    ...override,
+    thresholds: { ...base.thresholds, ...override.thresholds },
+    claude: {
+      ...base.claude,
+      ...override.claude,
+      aliases: { ...base.claude.aliases, ...override.claude?.aliases }
+    },
+    codex: {
+      ...base.codex,
+      ...override.codex,
+      fallbackModels: { ...base.codex.fallbackModels, ...override.codex?.fallbackModels }
+    },
+    overrides: override.overrides ?? base.overrides
+  };
+}

package/lib/models.js

@@ -0,0 +1,50 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export async function chooseModel({ agent, tier, config, refreshModels }) {
+  if (agent === "claude") {
+    return { model: config.claude.aliases[tier] ?? config.claude.aliases.balanced, source: "claude-alias" };
+  }
+  const catalog = await loadCodexCatalog(config, refreshModels);
+  const selected = selectCodexModel(catalog, tier) ?? config.codex.fallbackModels[tier] ?? config.codex.fallbackModels.balanced;
+  return { model: selected, source: catalog.length ? "codex-debug-models" : "fallback" };
+}
+
+async function loadCodexCatalog(config) {
+  const [command, ...args] = config.codex.discoveryCommand.split(/\s+/);
+  try {
+    const { stdout } = await execFileAsync(command, args, { timeout: 5000, maxBuffer: 1024 * 1024 * 6 });
+    const line = stdout.trim().split("\n").find((item) => item.trim().startsWith("{"));
+    const parsed = JSON.parse(line);
+    return Array.isArray(parsed.models) ? parsed.models.filter((model) => model.visibility !== "hidden") : [];
+  } catch {
+    return [];
+  }
+}
+
+function selectCodexModel(models, tier) {
+  if (!models.length) return null;
+  const visible = models.map((model) => ({
+    slug: model.slug,
+    text: `${model.slug} ${model.display_name ?? ""} ${model.description ?? ""}`.toLowerCase(),
+    priority: Number.isFinite(model.priority) ? model.priority : 1000,
+    context: model.context_window ?? 0
+  }));
+  if (tier === "simple") return best(visible, [/mini|small|fast|efficient/], [/frontier|complex/]);
+  if (tier === "balanced") return best(visible, [/gpt-5\.4$|balanced|coding|everyday/], [/mini/]);
+  return best(visible, [/gpt-5\.5|frontier|complex|real-world|large/], [/mini|small/]);
+}
+
+function best(models, positive, negative) {
+  return models
+    .map((model) => {
+      let score = 1000 - model.priority;
+      for (const regex of positive) if (regex.test(model.text)) score += 100;
+      for (const regex of negative) if (regex.test(model.text)) score -= 80;
+      score += Math.min(50, model.context / 20000);
+      return { ...model, score };
+    })
+    .sort((a, b) => b.score - a.score)[0]?.slug ?? null;
+}

package/lib/parsers/javascript.js

@@ -0,0 +1,38 @@
+import { readFile } from "node:fs/promises";
+import { parse } from "@babel/parser";
+
+export async function analyzeJavaScriptFile(file) {
+  try {
+    const source = await readFile(file, "utf8");
+    const ast = parse(source, {
+      sourceType: "unambiguous",
+      plugins: ["typescript", "jsx", "decorators-legacy", "classProperties", "dynamicImport"]
+    });
+    const summary = { ok: true, language: "javascript", functions: 0, classes: 0, branches: 0, imports: 0 };
+    walk(ast, (node) => {
+      if (!node || typeof node.type !== "string") return;
+      if (["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression", "ObjectMethod", "ClassMethod"].includes(node.type)) summary.functions += 1;
+      if (["ClassDeclaration", "ClassExpression"].includes(node.type)) summary.classes += 1;
+      if (["IfStatement", "ConditionalExpression", "ForStatement", "ForOfStatement", "ForInStatement", "WhileStatement", "DoWhileStatement", "SwitchCase", "TryStatement"].includes(node.type)) summary.branches += 1;
+      if (["ImportDeclaration", "ExportNamedDeclaration", "ExportAllDeclaration", "CallExpression"].includes(node.type)) {
+        if (node.type !== "CallExpression" || node.callee?.name === "require") summary.imports += 1;
+      }
+    });
+    return summary;
+  } catch (error) {
+    return { ok: false, file, error: error.message };
+  }
+}
+
+function walk(value, visit) {
+  if (!value || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    for (const item of value) walk(item, visit);
+    return;
+  }
+  visit(value);
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "loc" || key === "start" || key === "end") continue;
+    walk(child, visit);
+  }
+}

package/lib/parsers/python.js

@@ -0,0 +1,15 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import path from "node:path";
+
+const execFileAsync = promisify(execFile);
+
+export async function analyzePythonFile(file) {
+  try {
+    const script = path.resolve(new URL("../../../scripts/python_ast_summary.py", import.meta.url).pathname);
+    const { stdout } = await execFileAsync("python3", [script, file], { timeout: 5000 });
+    return { ok: true, language: "python", ...JSON.parse(stdout) };
+  } catch (error) {
+    return { ok: false, file, error: error.message };
+  }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@ast-ai-model-router/cli",
+  "version": "0.1.1",
+  "description": "AST-aware Claude and Codex model router for cost-conscious coding tasks.",
+  "type": "module",
+  "bin": {
+    "ast-ai-model-router": "bin/ast-ai-model-router.js",
+    "model-router": "bin/ast-ai-model-router.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "scripts/",
+    "skills/",
+    ".claude-plugin/",
+    ".codex-plugin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "lint": "node --check bin/ast-ai-model-router.js && node --check lib/*.js && node --check lib/parsers/*.js",
+    "changeset": "changeset",
+    "changeset:version": "changeset version",
+    "changeset:publish": "changeset publish",
+    "pack:dry-run": "npm publish --dry-run --registry=https://registry.npmjs.org --cache=.npm-cache",
+    "publish:local": "npm publish --registry=https://registry.npmjs.org --cache=.npm-cache --provenance --access public"
+  },
+  "keywords": [
+    "llm",
+    "token-economics",
+    "model-router",
+    "claude-code",
+    "codex",
+    "ast",
+    "prompt-cost"
+  ],
+  "author": {
+    "name": "Faraazuddin Mohammed",
+    "url": "https://github.com/faraa2m"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/faraa2m/ast-ai-model-router.git"
+  },
+  "homepage": "https://github.com/faraa2m/ast-ai-model-router#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@babel/parser": "^7.28.5"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.31.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/scripts/python_ast_summary.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+import ast
+import json
+import sys
+
+
+class Counter(ast.NodeVisitor):
+    def __init__(self):
+        self.functions = 0
+        self.classes = 0
+        self.branches = 0
+        self.imports = 0
+
+    def visit_FunctionDef(self, node):
+        self.functions += 1
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node):
+        self.functions += 1
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node):
+        self.classes += 1
+        self.generic_visit(node)
+
+    def visit_If(self, node):
+        self.branches += 1
+        self.generic_visit(node)
+
+    def visit_For(self, node):
+        self.branches += 1
+        self.generic_visit(node)
+
+    def visit_AsyncFor(self, node):
+        self.branches += 1
+        self.generic_visit(node)
+
+    def visit_While(self, node):
+        self.branches += 1
+        self.generic_visit(node)
+
+    def visit_Try(self, node):
+        self.branches += 1
+        self.generic_visit(node)
+
+    def visit_Import(self, node):
+        self.imports += len(node.names)
+
+    def visit_ImportFrom(self, node):
+        self.imports += len(node.names)
+
+
+def main():
+    with open(sys.argv[1], "r", encoding="utf-8") as handle:
+        tree = ast.parse(handle.read(), filename=sys.argv[1])
+    counter = Counter()
+    counter.visit(tree)
+    print(json.dumps(counter.__dict__))
+
+
+if __name__ == "__main__":
+    main()

package/skills/model-router/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: model-router
+description: Use AST AI Model Router to choose an appropriate Claude or Codex model from task and code complexity before launching or recommending an agent command.
+---
+
+# Model Router
+
+Use this skill when the user wants cost-aware model selection for a coding task.
+
+## Workflow
+
+1. Run an analysis command from the project root:
+
+```bash
+ast-ai-model-router analyze --agent codex --task "<task>"
+```
+
+or:
+
+```bash
+ast-ai-model-router analyze --agent claude --task "<task>"
+```
+
+2. If the user wants execution, launch through the wrapper:
+
+```bash
+ast-ai-model-router run codex --task "<task>" -- <codex args>
+```
+
+```bash
+ast-ai-model-router run claude --task "<task>" -- <claude args>
+```
+
+3. Explain the selected model in token-economics terms: simple tasks should use faster/cheaper models; complex migrations, security-sensitive work, and architecture planning should use stronger models.
+
+## Notes
+
+- Codex model names are discovered dynamically from `codex debug models`.
+- Claude model names use aliases: `haiku`, `sonnet`, `opus`, and `opusplan`.
+- The router analyzes JavaScript/TypeScript with Babel ASTs and Python with stdlib `ast`.