riskmodels 2.0.0

package/dist/commands/mcp.js

@@ -0,0 +1,59 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Resolve path to the built MCP server entry (mcp/dist/index.js).
+ *
+ * Order:
+ * 1. RISKMODELS_MCP_SERVER_PATH
+ * 2. --mcp-server-path CLI option
+ * 3. ./mcp/dist/index.js relative to cwd (repo root when running from RiskModels_API)
+ * 4. ../../mcp/dist/index.js relative to cli/dist (monorepo dev: npm link / npm run from repo)
+ */
+export function resolveMcpServerPath(explicit) {
+    if (process.env.RISKMODELS_MCP_SERVER_PATH?.trim()) {
+        return resolve(process.env.RISKMODELS_MCP_SERVER_PATH.trim());
+    }
+    if (explicit?.trim()) {
+        return resolve(explicit.trim());
+    }
+    const cwdCandidate = join(process.cwd(), "mcp", "dist", "index.js");
+    if (existsSync(cwdCandidate)) {
+        return cwdCandidate;
+    }
+    // cli/dist/commands → ../../../ = RiskModels_API repo root (sibling of cli/)
+    const fromCliDist = join(__dirname, "..", "..", "..", "mcp", "dist", "index.js");
+    if (existsSync(fromCliDist)) {
+        return fromCliDist;
+    }
+    return null;
+}
+export function mcpServeCommand() {
+    return new Command("mcp")
+        .description("Run the RiskModels MCP server over stdio (for Claude Desktop, Cursor, etc.). Same as: node /path/to/mcp/dist/index.js")
+        .option("-p, --mcp-server-path <path>", "Absolute path to mcp/dist/index.js (overrides env RISKMODELS_MCP_SERVER_PATH)")
+        .action((opts) => {
+        const path = resolveMcpServerPath(opts.mcpServerPath);
+        if (!path) {
+            console.error(chalk.red("Could not find MCP server build at mcp/dist/index.js.\n"));
+            console.error(chalk.yellow("Build it:  cd mcp && npm ci && npm run build\n" +
+                "Or set RISKMODELS_MCP_SERVER_PATH to the absolute path to mcp/dist/index.js\n" +
+                "Or run this command from the RiskModels_API repo root after building mcp/."));
+            process.exitCode = 1;
+            return;
+        }
+        const child = spawn(process.execPath, [path], {
+            stdio: "inherit",
+            env: { ...process.env },
+        });
+        child.on("exit", (code, signal) => {
+            if (signal)
+                process.exit(1);
+            process.exit(code ?? 1);
+        });
+    });
+}

package/dist/commands/metrics.d.ts

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

package/dist/commands/metrics.js

@@ -0,0 +1,29 @@
+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 metricsCommand() {
+    return new Command("metrics")
+        .description("Latest risk metrics snapshot for one ticker (GET /metrics/{ticker})")
+        .argument("<ticker>", "Ticker symbol, e.g. NVDA")
+        .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;
+        }
+    });
+}

package/dist/commands/portfolio.d.ts

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

package/dist/commands/portfolio.js

@@ -0,0 +1,80 @@
+import { readFile } from "node:fs/promises";
+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 portfolioCommand() {
+    const portfolio = new Command("portfolio").description("Portfolio-level API (POST /portfolio/risk-index)");
+    portfolio
+        .command("risk-index")
+        .description("Holdings-weighted L3 variance decomposition and optional ER time series")
+        .option("--file <path>", "JSON file: { positions: [{ ticker, weight }, ...] }")
+        .option("--stdin", "Read positions JSON from stdin")
+        .option("--time-series", "Include daily portfolio ER time series")
+        .option("--years <n>", "Years when --time-series (1–15)", "1")
+        .action(async (opts, cmd) => {
+        const json = cmd.optsWithGlobals().json ?? false;
+        const cfg = await loadConfig();
+        const auth = requireResolvedAuth(cfg, chalk.yellow);
+        if (!auth)
+            return;
+        let raw;
+        try {
+            if (opts.stdin) {
+                raw = await readStdin();
+            }
+            else if (opts.file) {
+                raw = await readFile(opts.file, "utf8");
+            }
+            else {
+                console.error(chalk.red("Provide --file <path> or --stdin with JSON body."));
+                process.exitCode = 1;
+                return;
+            }
+        }
+        catch (e) {
+            console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+            return;
+        }
+        let bodyIn;
+        try {
+            bodyIn = JSON.parse(raw);
+        }
+        catch {
+            console.error(chalk.red("Invalid JSON."));
+            process.exitCode = 1;
+            return;
+        }
+        const positions = bodyIn.positions;
+        if (!Array.isArray(positions)) {
+            console.error(chalk.red('JSON must include a "positions" array: { ticker, weight }.'));
+            process.exitCode = 1;
+            return;
+        }
+        const years = parseInt(String(opts.years ?? bodyIn.years ?? "1"), 10) || 1;
+        const timeSeries = opts.timeSeries ?? bodyIn.timeSeries ?? false;
+        try {
+            const { body, costUsd } = await apiFetchJson(auth, "POST", "/portfolio/risk-index", {
+                jsonBody: { positions, timeSeries, years },
+            });
+            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 portfolio;
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}

package/dist/commands/query.d.ts

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

package/dist/commands/query.js

@@ -0,0 +1,90 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { createClient } from "@supabase/supabase-js";
+import ora from "ora";
+import { loadConfig, isDirectReady, needsConfigMessage, needsApiKeyMessage } from "../lib/config.js";
+import { resolveApiAuth } from "../lib/credentials.js";
+import { apiFetchJson } from "../lib/api-client.js";
+import { validateQuery, ensureLimitClause } from "../lib/sql-validation.js";
+import { printResults } from "../lib/display.js";
+async function runBilledQuery(auth, sql, limit) {
+    const finalSql = ensureLimitClause(sql, limit);
+    const { body, costUsd } = await apiFetchJson(auth, "POST", "/cli/query", {
+        jsonBody: { sql: finalSql, limit },
+    });
+    return { body, costUsd };
+}
+async function runDirectQuery(supabaseUrl, serviceKey, sql, limit) {
+    const validation = validateQuery(sql);
+    if (!validation.valid) {
+        throw new Error(validation.error);
+    }
+    const finalSql = ensureLimitClause(validation.sanitized, limit);
+    const supabase = createClient(supabaseUrl, serviceKey, {
+        auth: { persistSession: false, autoRefreshToken: false },
+    });
+    const { data, error } = await supabase.rpc("exec_sql", { query: finalSql });
+    if (error) {
+        throw new Error(error.message);
+    }
+    return { results: data ?? [], count: Array.isArray(data) ? data.length : 0, sql: finalSql };
+}
+export function queryCommand() {
+    return new Command("query")
+        .description("Run a read-only SQL query (billed: HTTP API, direct: Supabase exec_sql)")
+        .argument("<sql>", "SELECT statement")
+        .option("-l, --limit <n>", "Max rows when query has no LIMIT", "100")
+        .action(async (sqlArg, opts, cmd) => {
+        const json = cmd.optsWithGlobals().json ?? false;
+        const limit = parseInt(String(opts.limit ?? "100"), 10) || 100;
+        const cfg = await loadConfig();
+        if (!isDirectReady(cfg) && !resolveApiAuth(cfg)) {
+            if (cfg?.mode === "direct") {
+                console.error(chalk.yellow(needsConfigMessage()));
+            }
+            else {
+                console.error(chalk.yellow(needsApiKeyMessage()));
+            }
+            process.exitCode = 1;
+            return;
+        }
+        const validation = validateQuery(sqlArg);
+        if (!validation.valid) {
+            console.error(chalk.red(validation.error));
+            process.exitCode = 1;
+            return;
+        }
+        const auth = resolveApiAuth(cfg);
+        if (auth && !isDirectReady(cfg)) {
+            const spinner = json ? null : ora("Running query…").start();
+            try {
+                const { body, costUsd } = await runBilledQuery(auth, validation.sanitized, limit);
+                spinner?.succeed("Done");
+                printResults(body, json);
+                if (!json && costUsd) {
+                    console.log(chalk.dim(`Cost: $${costUsd}`));
+                }
+            }
+            catch (e) {
+                spinner?.fail("Query failed");
+                console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+                process.exitCode = 1;
+            }
+            return;
+        }
+        if (isDirectReady(cfg)) {
+            const spinner = json ? null : ora("Running query…").start();
+            try {
+                const body = await runDirectQuery(cfg.supabaseUrl, cfg.serviceRoleKey, validation.sanitized, limit);
+                spinner?.succeed("Done");
+                printResults(body, json);
+            }
+            catch (e) {
+                spinner?.fail("Query failed");
+                console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+                process.exitCode = 1;
+            }
+            return;
+        }
+    });
+}

package/dist/commands/rankings.d.ts

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

package/dist/commands/rankings.js

@@ -0,0 +1,108 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { loadConfig } from "../lib/config.js";
+import { requireResolvedAuth, resolveApiAuth } from "../lib/credentials.js";
+import { apiFetchJson, apiFetchOptionalAuth } from "../lib/api-client.js";
+import { apiRootFromUserBase } from "../lib/api-url.js";
+import { printResults } from "../lib/display.js";
+export function rankingsCommand() {
+    const rank = new Command("rankings").description("Cross-sectional rankings (GET /rankings/...)");
+    rank
+        .command("snapshot")
+        .description("Full or filtered ranking grid for one ticker (GET /rankings/{ticker})")
+        .argument("<ticker>", "Symbol")
+        .option("--metric <m>", "mkt_cap | gross_return | sector_residual | ...")
+        .option("--cohort <c>", "universe | sector | subsector")
+        .option("--window <w>", "1d | 21d | 63d | 252d")
+        .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 = {};
+        if (opts.metric)
+            query.metric = opts.metric;
+        if (opts.cohort)
+            query.cohort = opts.cohort;
+        if (opts.window)
+            query.window = opts.window;
+        try {
+            const { body, costUsd } = await apiFetchJson(auth, "GET", `/rankings/${enc}`, { 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;
+        }
+    });
+    rank
+        .command("badge")
+        .description("Shields.io-style badge JSON (GET /rankings/{ticker}/badge; Bearer optional)")
+        .argument("<ticker>", "Symbol")
+        .option("--token <t>", "When server requires RANKINGS_BADGE_TOKEN")
+        .option("--metric <m>", "Ranking metric")
+        .option("--cohort <c>", "universe | sector | subsector")
+        .option("--window <w>", "1d | 21d | 63d | 252d")
+        .action(async (ticker, opts, cmd) => {
+        const json = cmd.optsWithGlobals().json ?? false;
+        const cfg = await loadConfig();
+        const apiRoot = apiRootFromUserBase(cfg?.apiBaseUrl);
+        const auth = resolveApiAuth(cfg);
+        const enc = encodeURIComponent(ticker.trim());
+        const query = {};
+        if (opts.token)
+            query.token = opts.token;
+        if (opts.metric)
+            query.metric = opts.metric;
+        if (opts.cohort)
+            query.cohort = opts.cohort;
+        if (opts.window)
+            query.window = opts.window;
+        try {
+            const { body } = await apiFetchOptionalAuth(apiRoot, "GET", `/rankings/${enc}/badge`, {
+                query,
+                auth: auth ?? undefined,
+            });
+            printResults(body, json);
+        }
+        catch (e) {
+            console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+    rank
+        .command("top")
+        .description("Leaderboard: best names for metric × cohort × window (GET /rankings/top)")
+        .requiredOption("--metric <m>", "mkt_cap | gross_return | ...")
+        .requiredOption("--cohort <c>", "universe | sector | subsector")
+        .requiredOption("--window <w>", "1d | 21d | 63d | 252d")
+        .option("--limit <n>", "Rows (1–100)", "10")
+        .action(async (opts, cmd) => {
+        const json = cmd.optsWithGlobals().json ?? false;
+        const cfg = await loadConfig();
+        const auth = requireResolvedAuth(cfg, chalk.yellow);
+        if (!auth)
+            return;
+        const query = {
+            metric: opts.metric,
+            cohort: opts.cohort,
+            window: opts.window,
+            limit: parseInt(String(opts.limit ?? "10"), 10) || 10,
+        };
+        try {
+            const { body, costUsd } = await apiFetchJson(auth, "GET", "/rankings/top", { 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 rank;
+}

package/dist/commands/returns.d.ts

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

package/dist/commands/returns.js

@@ -0,0 +1,77 @@
+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 returnsCommand() {
+    const ret = new Command("returns").description("Return time series for stocks and ETFs (GET /ticker-returns)");
+    ret
+        .command("ticker")
+        .description("Daily returns for a stock or ETF (GET /ticker-returns). Stocks include L3 hedge ratios; ETFs return date/returns_gross/price_close only.")
+        .argument("<ticker>", "Symbol, e.g. NVDA or SPY")
+        .option("--years <n>", "Years of history (1–15)", "1")
+        .option("--limit <n>", "Max rows")
+        .option("--nocache", "Bypass cache")
+        .action(async (ticker, opts, cmd) => {
+        const years = parseInt(String(opts.years ?? "1"), 10) || 1;
+        const query = {
+            ticker: ticker.trim(),
+            years,
+            format: "json",
+        };
+        if (opts.limit)
+            query.limit = parseInt(opts.limit, 10);
+        if (opts.nocache)
+            query.nocache = true;
+        await runReturns(cmd, "/ticker-returns", query);
+    });
+    // Deprecated aliases: /returns and /etf-returns were removed. Forward to
+    // /ticker-returns (which now accepts both stocks and ETFs) and print a notice.
+    ret
+        .command("stock")
+        .description("DEPRECATED: alias for 'returns ticker'. Forwards to GET /ticker-returns.")
+        .argument("<ticker>", "Symbol")
+        .option("--years <n>", "Years of history (1–15)", "1")
+        .action(async (ticker, opts, cmd) => {
+        console.error(chalk.yellow("[deprecated] 'returns stock' is now an alias for 'returns ticker'. /returns was removed."));
+        const years = parseInt(String(opts.years ?? "1"), 10) || 1;
+        await runReturns(cmd, "/ticker-returns", {
+            ticker: ticker.trim(),
+            years,
+            format: "json",
+        });
+    });
+    ret
+        .command("etf")
+        .description("DEPRECATED: alias for 'returns ticker'. Forwards to GET /ticker-returns (ETFs now flow through /ticker-returns).")
+        .argument("<etf>", "ETF symbol, e.g. SPY")
+        .option("--years <n>", "Years of history (1–15)", "1")
+        .action(async (etf, opts, cmd) => {
+        console.error(chalk.yellow("[deprecated] 'returns etf' is now an alias for 'returns ticker'. /etf-returns was removed; ETFs are served via /ticker-returns."));
+        const years = parseInt(String(opts.years ?? "1"), 10) || 1;
+        await runReturns(cmd, "/ticker-returns", {
+            ticker: etf.trim(),
+            years,
+            format: "json",
+        });
+    });
+    return ret;
+}
+async function runReturns(cmd, path, query) {
+    const json = cmd.optsWithGlobals().json ?? false;
+    const cfg = await loadConfig();
+    const auth = requireResolvedAuth(cfg, chalk.yellow);
+    if (!auth)
+        return;
+    try {
+        const { body, costUsd } = await apiFetchJson(auth, "GET", path, { 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;
+    }
+}

package/dist/commands/schema.d.ts

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

package/dist/commands/schema.js

@@ -0,0 +1,77 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { loadConfig, isDirectReady, needsConfigMessage } from "../lib/config.js";
+import { printResults } from "../lib/display.js";
+function sanitizeTableName(name) {
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+        return null;
+    }
+    return name;
+}
+export function schemaCommand() {
+    return new Command("schema")
+        .description("Inspect PostgREST schema (direct / Supabase mode only)")
+        .option("-t, --table <name>", "Show a single table definition")
+        .action(async (opts, cmd) => {
+        const json = cmd.optsWithGlobals().json ?? false;
+        const cfg = await loadConfig();
+        if (!isDirectReady(cfg)) {
+            if (cfg?.mode === "billed") {
+                console.error(chalk.yellow("Schema introspection is only available in direct (Supabase) mode. Use the Supabase dashboard or run: riskmodels config init and choose Service Role mode."));
+            }
+            else {
+                console.error(chalk.yellow(needsConfigMessage()));
+            }
+            process.exitCode = 1;
+            return;
+        }
+        if (opts.table) {
+            const safe = sanitizeTableName(opts.table);
+            if (!safe) {
+                console.error(chalk.red("Invalid table name"));
+                process.exitCode = 1;
+                return;
+            }
+        }
+        const base = cfg.supabaseUrl.replace(/\/$/, "");
+        const url = `${base}/rest/v1/`;
+        const key = cfg.serviceRoleKey;
+        const res = await fetch(url, {
+            headers: {
+                Accept: "application/openapi+json",
+                apikey: key,
+                Authorization: `Bearer ${key}`,
+            },
+        });
+        if (!res.ok) {
+            const t = await res.text();
+            console.error(chalk.red(`OpenAPI fetch failed: ${res.status} ${t.slice(0, 300)}`));
+            process.exitCode = 1;
+            return;
+        }
+        const spec = (await res.json());
+        const schemas = spec.definitions ?? spec.components?.schemas ?? {};
+        if (opts.table) {
+            const safe = sanitizeTableName(opts.table);
+            const tableKey = Object.keys(schemas).find((k) => k.toLowerCase() === safe.toLowerCase());
+            if (!tableKey) {
+                console.error(chalk.red(`Table not found in OpenAPI schemas: ${safe}`));
+                process.exitCode = 1;
+                return;
+            }
+            printResults({ table: tableKey, schema: schemas[tableKey] }, json);
+            return;
+        }
+        const names = Object.keys(schemas).sort();
+        if (json) {
+            printResults({ tables: names, openapi_version: spec.openapi }, true);
+        }
+        else {
+            console.log(chalk.bold("Tables (from OpenAPI schemas):"));
+            for (const n of names) {
+                console.log(`  ${n}`);
+            }
+            console.log(chalk.dim(`\nDetail: riskmodels schema --table <name>`));
+        }
+    });
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,25 @@
+import { Command } from "commander";
+import { configPath, loadConfig, maskSecret } from "../lib/config.js";
+import { detectClients, selectedClients } from "../lib/mcp-config-paths.js";
+import { printResults } from "../lib/display.js";
+export function statusCommand() {
+    return new Command("status")
+        .description("Show RiskModels CLI and MCP client configuration status")
+        .option("--client <name>", "claude | cursor | codex | vscode")
+        .option("--all", "Check all supported clients")
+        .option("--json", "JSON output")
+        .action(async (opts, cmd) => {
+        const json = opts.json || cmd.optsWithGlobals().json || false;
+        const cfg = await loadConfig();
+        const clients = selectedClients({ client: opts.client, all: opts.all });
+        const detections = await detectClients(clients);
+        printResults({
+            configPath: configPath(),
+            configFound: !!cfg,
+            apiBaseUrl: cfg?.apiBaseUrl ?? "https://riskmodels.app",
+            apiKey: maskSecret(cfg?.apiKey),
+            oauthConfigured: !!cfg?.clientId && !!cfg?.clientSecret,
+            mcpClients: detections,
+        }, json);
+    });
+}

package/dist/commands/tickers.d.ts

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

package/dist/commands/tickers.js

@@ -0,0 +1,36 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { loadConfig } from "../lib/config.js";
+import { apiRootFromUserBase } from "../lib/api-url.js";
+import { apiFetchOptionalAuth } from "../lib/api-client.js";
+import { printResults } from "../lib/display.js";
+export function tickersCommand() {
+    return new Command("tickers")
+        .description("Ticker universe search (GET /tickers, no auth required)")
+        .option("--search <q>", "Match symbol or company name")
+        .option("--mag7", "MAG7 names only")
+        .option("--metadata", "Include sector / ETF metadata")
+        .option("--array <name>", "ticker | teo (full symbol list or trading dates)")
+        .action(async (opts, cmd) => {
+        const json = cmd.optsWithGlobals().json ?? false;
+        const cfg = await loadConfig();
+        const apiRoot = apiRootFromUserBase(cfg?.apiBaseUrl);
+        const query = {};
+        if (opts.search)
+            query.search = opts.search;
+        if (opts.mag7)
+            query.mag7 = true;
+        if (opts.metadata)
+            query.include_metadata = true;
+        if (opts.array)
+            query.array = opts.array;
+        try {
+            const { body } = await apiFetchOptionalAuth(apiRoot, "GET", "/tickers", { query });
+            printResults(body, json);
+        }
+        catch (e) {
+            console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/uninstall.d.ts

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