riskmodels 2.0.0

package/README.md

@@ -0,0 +1,104 @@
+# riskmodels
+
+Command-line interface for [RiskModels](https://riskmodels.app): call the REST API (metrics, batch, portfolio, returns, rankings, etc.), run billed SQL queries, explore schema in direct (Supabase) mode, check balance, and export agent tool manifests. Same contract as the Python SDK: **POST /decompose** returns variance shares and ETF hedge ratios per ticker.
+
+## Install
+
+```bash
+npm install -g riskmodels
+```
+
+Agent-first installer preview:
+
+```bash
+RISKMODELS_API_KEY=rm_agent_live_... npx riskmodels install
+```
+
+Local development can run the same flow with:
+
+```bash
+cd cli
+npm run build
+node dist/index.js install --dry-run
+```
+
+## Authentication
+
+- **API key (recommended):** `riskmodels config init` (billed mode) or `riskmodels config set apiKey <rm_agent_...>`.
+- **OAuth client credentials:** `riskmodels config set clientId …` and `config set clientSecret …`, or set `RISKMODELS_CLIENT_ID` / `RISKMODELS_CLIENT_SECRET` (optional `RISKMODELS_OAUTH_SCOPE`; default matches the Python SDK).
+- **Environment:** `RISKMODELS_API_KEY` works without a config file for REST commands.
+- **Direct (Supabase) mode** is for `query` + `schema` only. REST analytics need an API key or OAuth (config or env).
+
+Base URL: stored as `apiBaseUrl` (default `https://riskmodels.app`). The CLI calls paths under `…/api/...` (same as `OPENAPI_SPEC.yaml`).
+
+## Quick start (billed / recommended)
+
+```bash
+riskmodels config init
+# Choose API Key mode and enter your rm_agent_* key
+
+riskmodels health
+riskmodels metrics NVDA
+riskmodels query "SELECT ticker, company_name FROM ticker_metadata LIMIT 3"
+riskmodels balance
+```
+
+Config file: `~/.config/riskmodels/config.json`
+
+## Commands
+
+| Command | Description |
+|--------|-------------|
+| `riskmodels config init \| set \| list` | API key, OAuth fields (`clientId`, `clientSecret`, `oauthScope`), `apiBaseUrl`, or Supabase (direct) |
+| `riskmodels install` | Detect Claude, Cursor, Codex, and VS Code MCP targets, store the API key in shared config, merge MCP configs with backups, and run a connection test. |
+| `riskmodels status` | Show shared config and MCP client detection status. |
+| `riskmodels doctor` | Local install-readiness diagnostics: Node, npx, API credentials, and client detection. |
+| `riskmodels uninstall` | Remove only the `riskmodels` MCP server block from supported client configs, with backups. |
+| `riskmodels query "<sql>"` | SELECT only (billed → `POST /api/cli/query`, direct → Supabase `exec_sql`) |
+| `riskmodels metrics <ticker>` | Latest snapshot (`GET /api/metrics/{ticker}`) |
+| `riskmodels batch analyze` | `POST /api/batch/analyze` (`--tickers`, `--metrics`, `--years`) |
+| `riskmodels portfolio risk-index` | `POST /api/portfolio/risk-index` (`--file` or `--stdin`) |
+| `riskmodels returns ticker <SYMBOL>` | `GET /api/ticker-returns` — daily returns for both stocks and ETFs. Stocks include L1/L2/L3 hedge ratios + explained-risk columns; ETFs (e.g. `SPY`) return date/returns_gross/price_close (L* null). `stock` / `etf` subcommands are deprecated aliases. |
+| `riskmodels l3 <ticker>` | `GET /api/l3-decomposition` |
+| `riskmodels correlation post\|metrics` | `POST /api/correlation`, `GET /api/metrics/{ticker}/correlation` |
+| `riskmodels macro-factors` | `GET /api/macro-factors` (daily macro returns, no ticker) |
+| `riskmodels rankings snapshot\|badge\|top` | Rankings endpoints |
+| `riskmodels tickers` | Universe search (`GET /api/tickers`, no auth) |
+| `riskmodels health` | `GET /api/health` (no auth) |
+| `riskmodels estimate` | `POST /api/estimate` (pre-flight cost) |
+| `riskmodels schema` | PostgREST OpenAPI (direct mode only) |
+| `riskmodels balance` | Account balance (`GET /api/balance`) |
+| `riskmodels manifest [--format openai\|anthropic\|zed]` | Static tool manifest (no auth) |
+| `riskmodels agent decompose\|monitor` | Shortcuts → batch analyze / metrics |
+
+Global flag: `--json` for machine-readable output on supported commands.
+
+### MCP installer safety
+
+`riskmodels install --dry-run` detects supported clients, prints target config paths, redacts secrets, and shows the exact `npx -y @riskmodels/mcp` server entry it will merge. `riskmodels install` performs the write with timestamped backups.
+
+Default credential policy:
+
+- Use `~/.config/riskmodels/config.json`.
+- Do not embed API keys in MCP config files.
+- `--embed-key` is explicit opt-in and redacted in dry-run output.
+- Safe writes create timestamped backups, validate JSON/TOML before writing, run a connection test, and keep uninstall scoped to the `riskmodels` MCP server block.
+
+## Develop
+
+```bash
+cd cli
+npm install
+npm run build
+npm run install:global   # npm link for local testing
+```
+
+The repo root `npm run typecheck` includes `cli/src` (see `AGENTS.md`). Maintainer drift check: `npm run cli:openapi-check` at the repo root.
+
+## npm releases (maintainers)
+
+Publishing (`npm publish`, version bumps, npm login / tokens) is **not** documented in this public README. It is maintained in the private **BWMACRO** monorepo at **`docs/RISKMODELS_CLI_NPM_PUBLISHING.md`** — open that file from your internal BWMACRO clone.
+
+**Rule of thumb:** run publish commands only from **`cli/`**; the repo root package is the Next.js portal, not this CLI.
+
+The legacy `riskmodels-cli` npm package remains a backward-compatible published artifact. New releases from this directory target the unscoped `riskmodels` package for `npx riskmodels install`.

package/dist/commands/agent.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function agentCommand(): Command;

package/dist/commands/agent.js

@@ -0,0 +1,76 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { loadConfig } from "../lib/config.js";
+import { requireResolvedAuth } from "../lib/credentials.js";
+import { apiFetchJson } from "../lib/api-client.js";
+import { printResults } from "../lib/display.js";
+const DOCS = "https://riskmodels.app/docs/api";
+function parseTickers(s) {
+    return s
+        .split(/[\s,]+/)
+        .map((t) => t.trim())
+        .filter(Boolean);
+}
+export function agentCommand() {
+    const agent = new Command("agent").description("Shortcuts for portfolio-style workflows (wraps REST endpoints)");
+    agent
+        .command("decompose")
+        .description("Batch L3-style screen: POST /batch/analyze with full_metrics (+ hedge_ratios)")
+        .requiredOption("--tickers <symbols>", "Comma or space separated tickers (max 100)")
+        .option("--years <n>", "Years when returns blocks are requested", "1")
+        .action(async (opts, cmd) => {
+        const json = cmd.optsWithGlobals().json ?? false;
+        const cfg = await loadConfig();
+        const auth = requireResolvedAuth(cfg, chalk.yellow);
+        if (!auth)
+            return;
+        const tickers = parseTickers(opts.tickers);
+        if (tickers.length === 0 || tickers.length > 100) {
+            console.error(chalk.red("Provide 1–100 tickers."));
+            process.exitCode = 1;
+            return;
+        }
+        const years = parseInt(String(opts.years ?? "1"), 10) || 1;
+        try {
+            const { body, costUsd } = await apiFetchJson(auth, "POST", "/batch/analyze", {
+                jsonBody: {
+                    tickers,
+                    metrics: ["full_metrics", "hedge_ratios"],
+                    years,
+                    format: "json",
+                },
+            });
+            printResults(body, json);
+            if (!json && costUsd)
+                console.log(chalk.dim(`Cost: $${costUsd}`));
+        }
+        catch (e) {
+            console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+    agent
+        .command("monitor")
+        .description("Latest risk snapshot for one holding: GET /metrics/{ticker}")
+        .argument("<ticker>", "Symbol to poll")
+        .action(async (ticker, _opts, cmd) => {
+        const json = cmd.optsWithGlobals().json ?? false;
+        const cfg = await loadConfig();
+        const auth = requireResolvedAuth(cfg, chalk.yellow);
+        if (!auth)
+            return;
+        const enc = encodeURIComponent(ticker.trim());
+        try {
+            const { body, costUsd } = await apiFetchJson(auth, "GET", `/metrics/${enc}`);
+            printResults(body, json);
+            if (!json && costUsd)
+                console.log(chalk.dim(`Cost: $${costUsd}`));
+        }
+        catch (e) {
+            console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+    agent.addHelpText("after", `\n${chalk.dim(`More endpoints: ${DOCS} — or run \`riskmodels --help\` for the full CLI.`)}`);
+    return agent;
+}

package/dist/commands/balance.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function balanceCommand(): Command;

package/dist/commands/balance.js

@@ -0,0 +1,25 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { loadConfig } from "../lib/config.js";
+import { requireResolvedAuth } from "../lib/credentials.js";
+import { apiFetchJson } from "../lib/api-client.js";
+import { printResults } from "../lib/display.js";
+export function balanceCommand() {
+    return new Command("balance")
+        .description("Show account balance (billed credentials)")
+        .action(async (_opts, cmd) => {
+        const json = cmd.optsWithGlobals().json ?? false;
+        const cfg = await loadConfig();
+        const auth = requireResolvedAuth(cfg, chalk.yellow);
+        if (!auth)
+            return;
+        try {
+            const { body } = await apiFetchJson(auth, "GET", "/balance");
+            printResults(body, json);
+        }
+        catch (e) {
+            console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/batch.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function batchCommand(): Command;

package/dist/commands/batch.js

@@ -0,0 +1,76 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { loadConfig } from "../lib/config.js";
+import { requireResolvedAuth } from "../lib/credentials.js";
+import { apiFetchJson } from "../lib/api-client.js";
+import { printResults } from "../lib/display.js";
+const METRIC_CHOICES = ["returns", "l3_decomposition", "hedge_ratios", "full_metrics"];
+function parseTickers(s) {
+    return s
+        .split(/[\s,]+/)
+        .map((t) => t.trim())
+        .filter(Boolean);
+}
+function parseMetrics(s) {
+    if (!s?.trim())
+        return ["full_metrics"];
+    const parts = s.split(/[\s,]+/).map((x) => x.trim());
+    for (const p of parts) {
+        if (!METRIC_CHOICES.includes(p)) {
+            throw new Error(`Invalid metric "${p}". Use: ${METRIC_CHOICES.join(", ")}`);
+        }
+    }
+    return parts;
+}
+export function batchCommand() {
+    const batch = new Command("batch").description("Multi-ticker batch analysis (POST /batch/analyze)");
+    batch
+        .command("analyze")
+        .description("Fetch metrics for up to 100 tickers")
+        .requiredOption("--tickers <symbols>", "Comma or space separated tickers, e.g. AAPL,MSFT,NVDA")
+        .option("--metrics <list>", `Comma-separated: ${METRIC_CHOICES.join(", ")} (default: full_metrics)`)
+        .option("--years <n>", "Years of history for returns / l3_decomposition", "1")
+        .option("--format <fmt>", "json | parquet | csv", "json")
+        .action(async (opts, cmd) => {
+        const json = cmd.optsWithGlobals().json ?? false;
+        const cfg = await loadConfig();
+        const auth = requireResolvedAuth(cfg, chalk.yellow);
+        if (!auth)
+            return;
+        let metrics;
+        try {
+            metrics = parseMetrics(opts.metrics);
+        }
+        catch (e) {
+            console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+            return;
+        }
+        const years = parseInt(String(opts.years ?? "1"), 10) || 1;
+        const format = (opts.format ?? "json");
+        const tickers = parseTickers(opts.tickers);
+        if (tickers.length === 0 || tickers.length > 100) {
+            console.error(chalk.red("Provide 1–100 tickers."));
+            process.exitCode = 1;
+            return;
+        }
+        if (format !== "json") {
+            console.error(chalk.red("CLI supports JSON responses only; omit --format or use --format json."));
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const { body, costUsd } = await apiFetchJson(auth, "POST", "/batch/analyze", {
+                jsonBody: { tickers, metrics, years, format: "json" },
+            });
+            printResults(body, json);
+            if (!json && costUsd)
+                console.log(chalk.dim(`Cost: $${costUsd}`));
+        }
+        catch (e) {
+            console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+    return batch;
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function configCommand(): Command;

package/dist/commands/config.js

@@ -0,0 +1,152 @@
+import { Command } from "commander";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { loadConfig, saveConfig, maskSecret, DEFAULT_API_BASE, } from "../lib/config.js";
+import { printResults } from "../lib/display.js";
+export function configCommand() {
+    const cmd = new Command("config").description("Manage CLI configuration (~/.config/riskmodels/config.json)");
+    cmd
+        .command("init")
+        .description("Interactive setup (billed API key or direct Supabase)")
+        .action(async () => {
+        const existing = await loadConfig();
+        const { mode } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "mode",
+                message: "How should the CLI authenticate?",
+                choices: [
+                    { name: "API Key (billed, recommended for production)", value: "billed" },
+                    { name: "Service Role Key (direct Supabase, for development)", value: "direct" },
+                ],
+                default: existing?.mode ?? "billed",
+            },
+        ]);
+        if (mode === "billed") {
+            const answers = await inquirer.prompt([
+                {
+                    type: "password",
+                    name: "apiKey",
+                    message: "RiskModels API key (rm_agent_...)",
+                    mask: "*",
+                    validate: (v) => (v?.trim() ? true : "API key is required"),
+                },
+                {
+                    type: "input",
+                    name: "apiBaseUrl",
+                    message: "API base URL",
+                    default: existing?.apiBaseUrl ?? DEFAULT_API_BASE,
+                    validate: (v) => (v?.trim()?.startsWith("http") ? true : "Must be an https URL"),
+                },
+            ]);
+            const cfg = {
+                mode: "billed",
+                apiKey: answers.apiKey.trim(),
+                apiBaseUrl: answers.apiBaseUrl.replace(/\/$/, ""),
+            };
+            await saveConfig(cfg);
+            console.log(chalk.green("Saved billed mode configuration."));
+        }
+        else {
+            const answers = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "supabaseUrl",
+                    message: "Supabase project URL",
+                    default: existing?.supabaseUrl ?? "",
+                    validate: (v) => v?.includes("supabase.co") ? true : "URL should contain supabase.co",
+                },
+                {
+                    type: "password",
+                    name: "serviceRoleKey",
+                    message: "Supabase service role key (JWT, often starts with ey...)",
+                    mask: "*",
+                    validate: (v) => (v?.trim()?.startsWith("ey") ? true : "Key should start with ey"),
+                },
+            ]);
+            const cfg = {
+                mode: "direct",
+                supabaseUrl: answers.supabaseUrl.trim().replace(/\/$/, ""),
+                serviceRoleKey: answers.serviceRoleKey.trim(),
+            };
+            await saveConfig(cfg);
+            console.log(chalk.green("Saved direct (Supabase) configuration."));
+        }
+    });
+    cmd
+        .command("set")
+        .description("Set a config value")
+        .argument("<key>", "apiKey | apiBaseUrl | clientId | clientSecret | oauthScope | supabaseUrl | serviceRoleKey")
+        .argument("<value>", "value to store")
+        .action(async (key, value) => {
+        const allowed = new Set([
+            "apiKey",
+            "apiBaseUrl",
+            "clientId",
+            "clientSecret",
+            "oauthScope",
+            "supabaseUrl",
+            "serviceRoleKey",
+        ]);
+        if (!allowed.has(key)) {
+            console.error(chalk.red(`Unknown key: ${key}`));
+            process.exitCode = 1;
+            return;
+        }
+        const cfg = (await loadConfig()) ?? { mode: "billed" };
+        if (key === "apiKey") {
+            cfg.mode = "billed";
+            cfg.apiKey = value;
+        }
+        else if (key === "apiBaseUrl") {
+            cfg.apiBaseUrl = value.replace(/\/$/, "");
+        }
+        else if (key === "clientId") {
+            cfg.mode = "billed";
+            cfg.clientId = value;
+        }
+        else if (key === "clientSecret") {
+            cfg.mode = "billed";
+            cfg.clientSecret = value;
+        }
+        else if (key === "oauthScope") {
+            cfg.mode = "billed";
+            cfg.oauthScope = value;
+        }
+        else if (key === "supabaseUrl") {
+            cfg.mode = "direct";
+            cfg.supabaseUrl = value.replace(/\/$/, "");
+        }
+        else if (key === "serviceRoleKey") {
+            cfg.mode = "direct";
+            cfg.serviceRoleKey = value;
+        }
+        await saveConfig(cfg);
+        console.log(chalk.green(`Set ${key}.`));
+    });
+    cmd
+        .command("list")
+        .description("Show current configuration (secrets masked)")
+        .option("--json", "JSON output")
+        .action(async (opts, cmd) => {
+        const json = opts.json || cmd.optsWithGlobals().json;
+        const cfg = await loadConfig();
+        if (!cfg) {
+            const empty = { mode: null, message: "No config file yet. Run: riskmodels config init" };
+            printResults(empty, !!json);
+            return;
+        }
+        const view = {
+            mode: cfg.mode,
+            apiBaseUrl: cfg.apiBaseUrl ?? DEFAULT_API_BASE,
+            apiKey: maskSecret(cfg.apiKey),
+            clientId: maskSecret(cfg.clientId),
+            clientSecret: maskSecret(cfg.clientSecret),
+            oauthScope: cfg.oauthScope ?? "(not set)",
+            supabaseUrl: cfg.supabaseUrl ?? "(not set)",
+            serviceRoleKey: maskSecret(cfg.serviceRoleKey),
+        };
+        printResults(view, !!json);
+    });
+    return cmd;
+}

package/dist/commands/correlation.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function correlationCommand(): Command;

package/dist/commands/correlation.js

@@ -0,0 +1,80 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { loadConfig } from "../lib/config.js";
+import { requireResolvedAuth } from "../lib/credentials.js";
+import { apiFetchJson } from "../lib/api-client.js";
+import { printResults } from "../lib/display.js";
+export function correlationCommand() {
+    const corr = new Command("correlation").description("Macro factor correlation (POST /correlation, GET /metrics/.../correlation)");
+    corr
+        .command("post")
+        .description("Batch or single ticker correlation vs macro factors (POST /correlation)")
+        .requiredOption("--ticker <sym>", "One ticker, or comma-separated list (max 50)")
+        .option("--factors <list>", "Comma-separated factor keys (default: all six)")
+        .option("--return-type <t>", "gross | l1 | l2 | l3_residual", "l3_residual")
+        .option("--window-days <n>", "Rolling window length", "252")
+        .option("--method <m>", "pearson | spearman", "pearson")
+        .action(async (opts, cmd) => {
+        const json = cmd.optsWithGlobals().json ?? false;
+        const cfg = await loadConfig();
+        const auth = requireResolvedAuth(cfg, chalk.yellow);
+        if (!auth)
+            return;
+        const tickersStr = opts.ticker.trim();
+        const tickersParts = tickersStr.split(/[\s,]+/).filter(Boolean);
+        const tickerField = tickersParts.length > 1 ? tickersParts : tickersStr;
+        const body = {
+            ticker: tickerField,
+            return_type: opts.returnType ?? "l3_residual",
+            window_days: parseInt(String(opts.windowDays ?? "252"), 10) || 252,
+            method: opts.method ?? "pearson",
+        };
+        if (opts.factors?.trim()) {
+            body.factors = opts.factors.split(/[\s,]+/).map((s) => s.trim()).filter(Boolean);
+        }
+        try {
+            const { body: resBody, costUsd } = await apiFetchJson(auth, "POST", "/correlation", { jsonBody: body });
+            printResults(resBody, json);
+            if (!json && costUsd)
+                console.log(chalk.dim(`Cost: $${costUsd}`));
+        }
+        catch (e) {
+            console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+    corr
+        .command("metrics")
+        .description("Single-ticker correlation via GET /metrics/{ticker}/correlation")
+        .argument("<ticker>", "Symbol")
+        .option("--factors <list>", "Comma-separated macro keys")
+        .option("--return-type <t>", "gross | l1 | l2 | l3_residual", "l3_residual")
+        .option("--window-days <n>", "Default 252", "252")
+        .option("--method <m>", "pearson | spearman", "pearson")
+        .action(async (ticker, opts, cmd) => {
+        const json = cmd.optsWithGlobals().json ?? false;
+        const cfg = await loadConfig();
+        const auth = requireResolvedAuth(cfg, chalk.yellow);
+        if (!auth)
+            return;
+        const enc = encodeURIComponent(ticker.trim());
+        const query = {
+            return_type: opts.returnType ?? "l3_residual",
+            window_days: parseInt(String(opts.windowDays ?? "252"), 10) || 252,
+            method: opts.method ?? "pearson",
+        };
+        if (opts.factors?.trim())
+            query.factors = opts.factors.trim();
+        try {
+            const { body, costUsd } = await apiFetchJson(auth, "GET", `/metrics/${enc}/correlation`, { query });
+            printResults(body, json);
+            if (!json && costUsd)
+                console.log(chalk.dim(`Cost: $${costUsd}`));
+        }
+        catch (e) {
+            console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+    return corr;
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function doctorCommand(): Command;

package/dist/commands/doctor.js

@@ -0,0 +1,51 @@
+import { spawnSync } from "node:child_process";
+import { Command } from "commander";
+import { configPath, loadConfig, maskSecret } from "../lib/config.js";
+import { detectClients } from "../lib/mcp-config-paths.js";
+import { printResults } from "../lib/display.js";
+function commandOk(command, args = ["--version"]) {
+    const result = spawnSync(command, args, { stdio: "ignore" });
+    return result.status === 0 || result.status === 1;
+}
+export function doctorCommand() {
+    return new Command("doctor")
+        .description("Run local diagnostics for RiskModels CLI and MCP install readiness")
+        .option("--json", "JSON output")
+        .action(async (opts, cmd) => {
+        const json = opts.json || cmd.optsWithGlobals().json || false;
+        const cfg = await loadConfig();
+        const clients = await detectClients(["claude", "cursor", "codex", "vscode"]);
+        const checks = [
+            {
+                id: "node",
+                ok: true,
+                detail: process.version,
+            },
+            {
+                id: "npx",
+                ok: commandOk("npx"),
+                detail: "Required to launch @riskmodels/mcp from MCP client configs.",
+            },
+            {
+                id: "api_credentials",
+                ok: !!cfg?.apiKey || !!process.env.RISKMODELS_API_KEY || (!!cfg?.clientId && !!cfg?.clientSecret),
+                detail: cfg?.apiKey
+                    ? `Config API key ${maskSecret(cfg.apiKey)} in ${configPath()}`
+                    : process.env.RISKMODELS_API_KEY
+                        ? "RISKMODELS_API_KEY is set in the environment."
+                        : "No API key found. Get one at https://riskmodels.app/get-api-key",
+            },
+            {
+                id: "mcp_package_target",
+                ok: true,
+                detail: "Installer targets npx -y @riskmodels/mcp once the package is published.",
+            },
+        ];
+        printResults({
+            ok: checks.every((check) => check.ok),
+            checks,
+            clients,
+            note: "Run `riskmodels install --dry-run` to inspect config writes, or `riskmodels install` to write configs with backups and run a connection test.",
+        }, json);
+    });
+}

package/dist/commands/estimate.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function estimateCommand(): Command;

package/dist/commands/estimate.js

@@ -0,0 +1,40 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { loadConfig } from "../lib/config.js";
+import { requireResolvedAuth } from "../lib/credentials.js";
+import { apiFetchJson } from "../lib/api-client.js";
+import { printResults } from "../lib/display.js";
+export function estimateCommand() {
+    return new Command("estimate")
+        .description("Estimate request cost before calling a metered endpoint (POST /estimate)")
+        .requiredOption("--endpoint <name>", "Target endpoint slug, e.g. ticker-returns, batch-analyze")
+        .option("--params-json <json>", "JSON object of params for the target endpoint (string)")
+        .action(async (opts, cmd) => {
+        const json = cmd.optsWithGlobals().json ?? false;
+        const cfg = await loadConfig();
+        const auth = requireResolvedAuth(cfg, chalk.yellow);
+        if (!auth)
+            return;
+        let params = {};
+        if (opts.paramsJson?.trim()) {
+            try {
+                params = JSON.parse(opts.paramsJson);
+            }
+            catch {
+                console.error(chalk.red("Invalid --params-json (must be JSON)."));
+                process.exitCode = 1;
+                return;
+            }
+        }
+        try {
+            const { body } = await apiFetchJson(auth, "POST", "/estimate", {
+                jsonBody: { endpoint: opts.endpoint, params },
+            });
+            printResults(body, json);
+        }
+        catch (e) {
+            console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/health.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function healthCommand(): Command;