@tokenomist-ai/tokenomist-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1237 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command11 } from "commander";
+
+// src/commands/token.ts
+import { Command } from "commander";
+
+// src/api/errors.ts
+function classifyStatus(status) {
+  if (status === 401) return "UNAUTHORIZED" /* UNAUTHORIZED */;
+  if (status === 403) return "FORBIDDEN" /* FORBIDDEN */;
+  if (status === 404) return "NOT_FOUND" /* NOT_FOUND */;
+  if (status === 429) return "RATE_LIMITED" /* RATE_LIMITED */;
+  if (status >= 500 && status < 600) return "SERVER_ERROR" /* SERVER_ERROR */;
+  return "UNKNOWN" /* UNKNOWN */;
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  return Number.isFinite(seconds) && seconds > 0 ? seconds : void 0;
+}
+var ApiError = class _ApiError extends Error {
+  constructor(message, code, detail, statusCode, retryAfter) {
+    super(message);
+    this.code = code;
+    this.detail = detail;
+    this.statusCode = statusCode;
+    this.retryAfter = retryAfter;
+    this.name = "ApiError";
+  }
+  retriesExhausted = false;
+  get retryable() {
+    return this.code === "RATE_LIMITED" /* RATE_LIMITED */ || this.code === "SERVER_ERROR" /* SERVER_ERROR */ || this.code === "NETWORK_ERROR" /* NETWORK_ERROR */;
+  }
+  static fromResponse(status, body, retryAfterHeader) {
+    const b = body && typeof body === "object" ? body : {};
+    const errorMessage = typeof b.errorMessage === "string" ? b.errorMessage : void 0;
+    const errorDetail = typeof b.errorDetail === "string" ? b.errorDetail : void 0;
+    if (status === 200 && b.status === false) {
+      const bodyStatus = typeof b.statusCode === "number" ? b.statusCode : 0;
+      const code2 = bodyStatus > 0 ? classifyStatus(bodyStatus) : "UNKNOWN" /* UNKNOWN */;
+      return new _ApiError(
+        errorMessage || "API request failed",
+        code2,
+        errorDetail,
+        bodyStatus || void 0
+      );
+    }
+    const code = classifyStatus(status);
+    return new _ApiError(
+      errorMessage || `HTTP ${status}`,
+      code,
+      errorDetail,
+      status,
+      parseRetryAfter(retryAfterHeader)
+    );
+  }
+  static fromNetworkError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return new _ApiError(message, "NETWORK_ERROR" /* NETWORK_ERROR */);
+  }
+};
+
+// src/api/retry.ts
+var DEFAULTS = {
+  maxAttempts: 3,
+  baseDelay: 1e3,
+  maxDelay: 3e4
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, options) {
+  const maxAttempts = options?.maxAttempts ?? DEFAULTS.maxAttempts;
+  const baseDelay = options?.baseDelay ?? DEFAULTS.baseDelay;
+  const maxDelay = options?.maxDelay ?? DEFAULTS.maxDelay;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (!(err instanceof ApiError) || !err.retryable) {
+        throw err;
+      }
+      lastError = err;
+      if (attempt === maxAttempts) {
+        break;
+      }
+      const jitter = Math.random() * 500;
+      const calculated = baseDelay * Math.pow(2, attempt - 1) + jitter;
+      const delay = err.retryAfter ? Math.min(err.retryAfter * 1e3, maxDelay) : Math.min(calculated, maxDelay);
+      process.stderr.write(
+        `${err.code}: ${err.message}. Retrying in ${Math.round(delay / 1e3)}s... (attempt ${attempt + 1}/${maxAttempts})
+`
+      );
+      await sleep(delay);
+    }
+  }
+  lastError.retriesExhausted = true;
+  throw lastError;
+}
+
+// src/api/cache.ts
+import { createHash } from "crypto";
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_CACHE_DIR = join(homedir(), ".tokenomist", "cache");
+var MAX_CACHE_FILES = 500;
+var ResponseCache = class {
+  constructor(ttl = 6e5, cacheDir = DEFAULT_CACHE_DIR) {
+    this.ttl = ttl;
+    this.cacheDir = cacheDir;
+  }
+  writeCount = 0;
+  buildKey(url, apiKey) {
+    const parsed = new URL(url);
+    parsed.searchParams.sort();
+    const prefix = apiKey ? createHash("md5").update(apiKey).digest("hex").slice(0, 8) : "";
+    const normalized = `${prefix}:GET:${parsed.toString()}`;
+    return createHash("md5").update(normalized).digest("hex");
+  }
+  get(key) {
+    try {
+      const filePath = join(this.cacheDir, `${key}.json`);
+      const raw = readFileSync(filePath, "utf-8");
+      const entry = JSON.parse(raw);
+      if (Date.now() - entry.timestamp > entry.ttl) {
+        try {
+          unlinkSync(filePath);
+        } catch {
+        }
+        return null;
+      }
+      return entry.data;
+    } catch {
+      return null;
+    }
+  }
+  set(key, url, data) {
+    try {
+      mkdirSync(this.cacheDir, { recursive: true, mode: 448 });
+      const entry = {
+        url,
+        timestamp: Date.now(),
+        ttl: this.ttl,
+        data
+      };
+      const filePath = join(this.cacheDir, `${key}.json`);
+      writeFileSync(filePath, JSON.stringify(entry), { encoding: "utf-8", mode: 384 });
+      this.writeCount++;
+      if (this.writeCount % 20 === 0) this.sweep();
+    } catch {
+    }
+  }
+  sweep() {
+    try {
+      const files = readdirSync(this.cacheDir).filter((f) => f.endsWith(".json"));
+      const now = Date.now();
+      for (const file of files) {
+        try {
+          const filePath = join(this.cacheDir, file);
+          const raw = readFileSync(filePath, "utf-8");
+          const entry = JSON.parse(raw);
+          if (now - entry.timestamp > entry.ttl) {
+            unlinkSync(filePath);
+          }
+        } catch {
+        }
+      }
+      const remaining = readdirSync(this.cacheDir).filter((f) => f.endsWith(".json"));
+      if (remaining.length > MAX_CACHE_FILES) {
+        const entries = remaining.map((file) => {
+          try {
+            const filePath = join(this.cacheDir, file);
+            const raw = readFileSync(filePath, "utf-8");
+            const entry = JSON.parse(raw);
+            return { file, timestamp: entry.timestamp };
+          } catch {
+            return { file, timestamp: 0 };
+          }
+        });
+        entries.sort((a, b) => a.timestamp - b.timestamp);
+        const toRemove = entries.slice(0, entries.length - MAX_CACHE_FILES);
+        for (const { file } of toRemove) {
+          try {
+            unlinkSync(join(this.cacheDir, file));
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/api/client.ts
+var HEADER_API_KEY = "x-api-key";
+var HEADER_CLIENT_SOURCE = "x-client-source";
+var CLIENT_SOURCE_CLI = "cli";
+var TokenomistClient = class {
+  constructor(apiKey, baseUrl, options) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+    this.options = options;
+    this.cache = new ResponseCache();
+  }
+  cache;
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    const urlStr = url.toString();
+    const cacheKey = this.cache.buildKey(urlStr, this.apiKey);
+    const useCache = this.options?.noCache !== true;
+    if (useCache) {
+      const cached = this.cache.get(cacheKey);
+      if (cached) return cached;
+    }
+    const data = await withRetry(() => this.fetchFromApi(url));
+    if (useCache) {
+      this.cache.set(cacheKey, urlStr, data);
+    }
+    return data;
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== "") {
+          url.searchParams.set(key, value);
+        }
+      }
+    }
+    return url;
+  }
+  async fetchFromApi(url) {
+    let res;
+    try {
+      res = await fetch(url.toString(), {
+        headers: {
+          [HEADER_API_KEY]: this.apiKey,
+          [HEADER_CLIENT_SOURCE]: CLIENT_SOURCE_CLI
+        }
+      });
+    } catch (err) {
+      throw ApiError.fromNetworkError(err);
+    }
+    if (!res.ok) {
+      let body2 = {};
+      try {
+        body2 = await res.json();
+      } catch {
+      }
+      const retryAfter = res.headers.get("retry-after") ?? void 0;
+      throw ApiError.fromResponse(res.status, body2, retryAfter);
+    }
+    const body = await res.json();
+    if (!body.status) {
+      throw ApiError.fromResponse(200, body);
+    }
+    return body.data;
+  }
+};
+
+// src/api/token.ts
+async function listTokens(client, params) {
+  return client.get("/v5/token/list", params);
+}
+async function searchTokens(client, query) {
+  return client.get("/v5/search-token", { query });
+}
+
+// src/output/table.ts
+import Table from "cli-table3";
+function renderTable(data, columns5) {
+  const table = new Table({
+    head: columns5.map((c) => c.header),
+    style: { head: ["cyan"] },
+    colAligns: columns5.map((c) => c.align || "left")
+  });
+  for (const row of data) {
+    table.push(columns5.map((c) => formatValue(row[c.key])));
+  }
+  return table.toString();
+}
+function formatValue(value) {
+  if (value === null || value === void 0) return "\u2014";
+  if (typeof value === "number") {
+    if (Number.isInteger(value)) return value.toLocaleString();
+    return value.toLocaleString(void 0, { maximumFractionDigits: 4 });
+  }
+  if (typeof value === "boolean") return value ? "Yes" : "No";
+  if (Array.isArray(value)) return value.join(", ");
+  return String(value);
+}
+
+// src/output/csv.ts
+function renderCsv(data, columns5) {
+  const header = columns5.map((c) => escapeCsv(c.header)).join(",");
+  const rows = data.map(
+    (row) => columns5.map((c) => escapeCsv(formatCsvValue(row[c.key]))).join(",")
+  );
+  return [header, ...rows].join("\n");
+}
+function escapeCsv(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function formatCsvValue(value) {
+  if (value === null || value === void 0) return "";
+  if (Array.isArray(value)) return value.join("; ");
+  return String(value);
+}
+
+// src/output/formatter.ts
+function format(data, columns5, mode) {
+  switch (mode) {
+    case "json":
+      return JSON.stringify(data, null, 2);
+    case "csv":
+      return renderCsv(data, columns5);
+    case "table":
+    default:
+      return renderTable(data, columns5);
+  }
+}
+function output(data, columns5, mode) {
+  console.log(format(data, columns5, mode));
+}
+
+// src/config/config.ts
+import { config as loadDotenv } from "dotenv";
+
+// src/config/store.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var CONFIG_DIR = join2(homedir2(), ".tokenomist");
+var CONFIG_PATH = join2(CONFIG_DIR, "config.json");
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+function loadConfigFile() {
+  try {
+    const raw = readFileSync2(CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function saveConfigFile(config) {
+  mkdirSync2(CONFIG_DIR, { recursive: true, mode: 448 });
+  writeFileSync2(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+function deleteConfigFile() {
+  try {
+    unlinkSync2(CONFIG_PATH);
+  } catch {
+  }
+}
+function maskApiKey(key) {
+  if (key.length <= 8) return "****";
+  return key.slice(0, 4) + "****" + key.slice(-4);
+}
+
+// src/config/config.ts
+loadDotenv();
+function resolveConfig(opts) {
+  const file = loadConfigFile();
+  const apiKey = opts.apiKey || process.env.TOKENOMIST_API_KEY || file.apiKey || "";
+  const baseUrl = opts.baseUrl || process.env.TOKENOMIST_BASE_URL || file.baseUrl || "https://api.tokenomist.ai";
+  if (!apiKey) {
+    console.error(
+      'Error: API key is required. Run "tokenomist auth login" or provide via --api-key / TOKENOMIST_API_KEY env var.'
+    );
+    process.exit(1);
+  }
+  return { apiKey, baseUrl, noCache: opts.cache === false };
+}
+
+// src/commands/token.ts
+var columns = [
+  { key: "id", header: "ID" },
+  { key: "name", header: "Name" },
+  { key: "symbol", header: "Symbol" },
+  { key: "marketCap", header: "Market Cap", align: "right" },
+  { key: "circulatingSupply", header: "Circ. Supply", align: "right" },
+  { key: "totalLockedAmount", header: "Locked", align: "right" },
+  { key: "unlockedAmount", header: "Unlocked", align: "right" },
+  { key: "lastUpdatedDate", header: "Updated" }
+];
+var searchColumns = [
+  { key: "tokenId", header: "ID" },
+  { key: "tokenName", header: "Name" },
+  { key: "tokenSymbol", header: "Symbol" }
+];
+var tokenCommand = new Command("token").description("Token commands");
+tokenCommand.command("list").description("List all tokens with summary data").option("--token-id <ids>", "Filter by token IDs (comma-separated)").action(async (opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await listTokens(client, {
+    tokenId: opts.tokenId
+  });
+  output(data, columns, globalOpts.output || "table");
+});
+tokenCommand.command("search <query>").description("Search for tokens by name, symbol, or slug").action(async (query, _opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await searchTokens(client, query);
+  output(data, searchColumns, globalOpts.output || "table");
+});
+
+// src/commands/unlock.ts
+import { Command as Command2 } from "commander";
+
+// src/api/unlock.ts
+async function listUnlockEvents(client, params) {
+  return client.get("/v5/unlock/events/list", params);
+}
+async function listUpcomingUnlockEvents(client, params) {
+  return client.get(
+    "/v5/unlock/events/upcoming",
+    params
+  );
+}
+async function getUnlockEvents(client, tokenSlug, params) {
+  return client.get(
+    `/v5/unlock/events/${encodeURIComponent(tokenSlug)}`,
+    params
+  );
+}
+
+// src/commands/unlock.ts
+var listColumns = [
+  { key: "tokenName", header: "Token" },
+  { key: "tokenSymbol", header: "Symbol" },
+  { key: "marketCap", header: "Market Cap", align: "right" },
+  { key: "releasedPercentage", header: "Released %", align: "right" },
+  { key: "eventCount", header: "Events", align: "right" }
+];
+var upcomingColumns = [
+  { key: "tokenName", header: "Token" },
+  { key: "tokenSymbol", header: "Symbol" },
+  { key: "marketCap", header: "Market Cap", align: "right" },
+  { key: "unlockDate", header: "Unlock Date" },
+  { key: "totalCliffAmount", header: "Cliff Amount", align: "right" },
+  { key: "totalCliffValue", header: "Cliff Value", align: "right" }
+];
+var eventsColumns = [
+  { key: "unlockDate", header: "Date" },
+  { key: "tokenName", header: "Token" },
+  { key: "tokenSymbol", header: "Symbol" },
+  { key: "cliffAmount", header: "Amount", align: "right" },
+  { key: "cliffValue", header: "Value", align: "right" },
+  { key: "valueToMarketCap", header: "Val/MCap", align: "right" }
+];
+function addPaginationOptions(cmd) {
+  return cmd.option("--page <number>", "Page number").option("--page-size <number>", "Items per page");
+}
+function addListFilterOptions(cmd) {
+  return addPaginationOptions(
+    cmd.option("--min-market-cap <value>", "Minimum market cap").option("--min-released-percentage <value>", "Minimum released percentage").option("--min-unlock-date <date>", "Min unlock date (YYYY-MM-DD)").option("--max-unlock-date <date>", "Max unlock date (YYYY-MM-DD)").option("--min-total-unlock-amount <value>", "Minimum total unlock amount").option("--min-value-to-market-cap <value>", "Min value-to-market-cap ratio").option("--standard-allocation <names>", "Filter by allocation (comma-separated)")
+  );
+}
+function addUpcomingFilterOptions(cmd) {
+  return addPaginationOptions(
+    cmd.option("--start <date>", "Start date (YYYY-MM-DD)").option("--end <date>", "End date (YYYY-MM-DD)").option("--standard-allocation <names>", "Filter by allocation (comma-separated)").option("--min-market-cap <value>", "Minimum market cap").option("--min-released-percentage <value>", "Minimum released percentage").option("--min-total-unlock-amount <value>", "Minimum total unlock amount").option("--min-value-to-market-cap <value>", "Min value-to-market-cap ratio")
+  );
+}
+var unlockCommand = new Command2("unlock").description("Token unlock event commands");
+addListFilterOptions(
+  unlockCommand.command("list").description("List unlock events grouped by token")
+).action(async (opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await listUnlockEvents(client, {
+    minMarketCap: opts.minMarketCap,
+    minReleasedPercentage: opts.minReleasedPercentage,
+    minUnlockDate: opts.minUnlockDate,
+    maxUnlockDate: opts.maxUnlockDate,
+    minTotalUnlockAmount: opts.minTotalUnlockAmount,
+    minValueToMarketCap: opts.minValueToMarketCap,
+    standardAllocation: opts.standardAllocation,
+    page: opts.page,
+    pageSize: opts.pageSize
+  });
+  const rows = data.map((d) => ({
+    ...d,
+    eventCount: d.events.length
+  }));
+  output(rows, listColumns, globalOpts.output || "table");
+});
+addUpcomingFilterOptions(
+  unlockCommand.command("upcoming").description("List next upcoming unlock event per token")
+).action(async (opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await listUpcomingUnlockEvents(client, {
+    start: opts.start,
+    end: opts.end,
+    standardAllocation: opts.standardAllocation,
+    minMarketCap: opts.minMarketCap,
+    minReleasedPercentage: opts.minReleasedPercentage,
+    minTotalUnlockAmount: opts.minTotalUnlockAmount,
+    minValueToMarketCap: opts.minValueToMarketCap,
+    page: opts.page,
+    pageSize: opts.pageSize
+  });
+  const rows = data.map((d) => ({
+    ...d,
+    unlockDate: d.upcomingEvent.unlockDate,
+    totalCliffAmount: d.upcomingEvent.cliffUnlocks.totalCliffAmount,
+    totalCliffValue: d.upcomingEvent.cliffUnlocks.totalCliffValue
+  }));
+  output(
+    rows,
+    upcomingColumns,
+    globalOpts.output || "table"
+  );
+});
+addPaginationOptions(
+  unlockCommand.command("events <tokenSlug>").description("Get unlock events for a specific token").option("--start <date>", "Start date (YYYY-MM-DD)").option("--end <date>", "End date (YYYY-MM-DD)").option("--standard-allocation <names>", "Filter by allocation (comma-separated)")
+).action(async (tokenSlug, opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await getUnlockEvents(client, tokenSlug, {
+    start: opts.start,
+    end: opts.end,
+    standardAllocation: opts.standardAllocation,
+    page: opts.page,
+    pageSize: opts.pageSize
+  });
+  const rows = data.map((d) => ({
+    ...d,
+    cliffAmount: d.cliffUnlocks.cliffAmount,
+    cliffValue: d.cliffUnlocks.cliffValue,
+    valueToMarketCap: d.cliffUnlocks.valueToMarketCap
+  }));
+  output(
+    rows,
+    eventsColumns,
+    globalOpts.output || "table"
+  );
+});
+
+// src/commands/investor.ts
+import { Command as Command3 } from "commander";
+
+// src/api/investor.ts
+async function listInvestors(client, params) {
+  return client.get(
+    "/v5/fundraising/investors/list",
+    params
+  );
+}
+async function getInvestorDetail(client, investorId, params) {
+  return client.get(
+    `/v5/fundraising/investors/${encodeURIComponent(investorId)}`,
+    params
+  );
+}
+
+// src/commands/investor.ts
+var listColumns2 = [
+  { key: "investorId", header: "ID" },
+  { key: "investorName", header: "Name" },
+  { key: "website", header: "Website" },
+  { key: "latestFundingDate", header: "Latest Funding" },
+  { key: "latestFundingRound", header: "Latest Round" },
+  { key: "roundCount", header: "Rounds", align: "right" }
+];
+var detailColumns = [
+  { key: "tokenId", header: "Token ID" },
+  { key: "roundName", header: "Round" },
+  { key: "isLeadInvestor", header: "Lead?" },
+  { key: "fundingDate", header: "Date" },
+  { key: "totalAmountRaisedinThatRound", header: "Raised", align: "right" },
+  { key: "valuation", header: "Valuation", align: "right" },
+  { key: "pricePerToken", header: "Price/Token", align: "right" }
+];
+var investorCommand = new Command3("investor").description("Investor commands");
+investorCommand.command("list").description("List all investors with their funding rounds").option("--start-latest-funding-date <date>", "Start date filter for latest funding (YYYY-MM-DD)").option("--end-latest-funding-date <date>", "End date filter for latest funding (YYYY-MM-DD)").option("--page <number>", "Page number").option("--page-size <number>", "Items per page").action(async (opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await listInvestors(client, {
+    startLatestFundingDate: opts.startLatestFundingDate,
+    endLatestFundingDate: opts.endLatestFundingDate,
+    page: opts.page,
+    pageSize: opts.pageSize
+  });
+  const rows = data.map((d) => ({
+    ...d,
+    roundCount: d.fundingRounds?.length || 0
+  }));
+  output(rows, listColumns2, globalOpts.output || "table");
+});
+investorCommand.command("detail <investorId>").description("Get investor detail with funding rounds").option("--is-lead-investor", "Filter by lead investor status").option("--funding-date-min <date>", "Min funding date (YYYY-MM-DD)").option("--funding-date-max <date>", "Max funding date (YYYY-MM-DD)").option("--raised-amount-min <value>", "Min raised amount").option("--raised-amount-max <value>", "Max raised amount").action(async (investorId, opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await getInvestorDetail(client, investorId, {
+    isLeadInvestor: opts.isLeadInvestor ? "true" : void 0,
+    fundingDateMin: opts.fundingDateMin,
+    fundingDateMax: opts.fundingDateMax,
+    raisedAmountMin: opts.raisedAmountMin,
+    raisedAmountMax: opts.raisedAmountMax
+  });
+  const outputMode = globalOpts.output || "table";
+  if (outputMode === "json") {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(`Investor: ${data.investorName}`);
+    console.log(`Website: ${data.website}`);
+    console.log(`Latest Funding: ${data.latestFundingDate}`);
+    console.log();
+    output(data.fundingRounds, detailColumns, outputMode);
+  }
+});
+
+// src/commands/fundraising.ts
+import { Command as Command4 } from "commander";
+
+// src/api/fundraising.ts
+async function getFundraising(client, tokenSlug, params) {
+  return client.get(
+    `/v5/fundraising/token/${encodeURIComponent(tokenSlug)}`,
+    params
+  );
+}
+
+// src/commands/fundraising.ts
+var columns2 = [
+  { key: "fundingRound", header: "Round" },
+  { key: "fundingDate", header: "Date" },
+  { key: "raiseType", header: "Type" },
+  { key: "amountRaised", header: "Raised", align: "right" },
+  { key: "valuation", header: "Valuation", align: "right" },
+  { key: "pricePerToken", header: "Price/Token", align: "right" },
+  { key: "numberOfInvestors", header: "Investors", align: "right" }
+];
+var fundraisingCommand = new Command4("fundraising").description("Get fundraising data for a token").argument("<tokenSlug>", "Token slug").option("--funding-date-min <date>", "Min funding date (YYYY-MM-DD)").option("--funding-date-max <date>", "Max funding date (YYYY-MM-DD)").option("--raised-amount-min <value>", "Min raised amount").option("--raised-amount-max <value>", "Max raised amount").action(async (tokenSlug, opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await getFundraising(client, tokenSlug, {
+    fundingDateMin: opts.fundingDateMin,
+    fundingDateMax: opts.fundingDateMax,
+    raisedAmountMin: opts.raisedAmountMin,
+    raisedAmountMax: opts.raisedAmountMax
+  });
+  const outputMode = globalOpts.output || "table";
+  if (outputMode === "json") {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(`Token: ${data.tokenName} (${data.tokenSymbol})`);
+    console.log(`Total Raised: ${data.totalAmountRaised ?? "\u2014"}`);
+    console.log(`Investor Released: ${data.investorReleasedPercentage ?? "\u2014"}%`);
+    console.log();
+    output(data.fundingRounds, columns2, outputMode);
+  }
+});
+
+// src/commands/burn.ts
+import { Command as Command5 } from "commander";
+
+// src/api/burn.ts
+async function listBurns(client, params) {
+  return client.get("/v5/burn/list", params);
+}
+async function getBurnDetail(client, tokenSlug, params) {
+  return client.get(
+    `/v5/burn/${encodeURIComponent(tokenSlug)}`,
+    params
+  );
+}
+
+// src/commands/burn.ts
+var listColumns3 = [
+  { key: "tokenId", header: "ID" },
+  { key: "tokenName", header: "Name" },
+  { key: "tokenSymbol", header: "Symbol" },
+  { key: "totalBurnAmount", header: "Total Burned", align: "right" }
+];
+var detailColumns2 = [
+  { key: "burnEventLabel", header: "Label" },
+  { key: "burnType", header: "Type" },
+  { key: "burnDate", header: "Date" },
+  { key: "amount", header: "Amount", align: "right" }
+];
+var burnCommand = new Command5("burn").description("Token burn commands");
+burnCommand.command("list").description("List all tokens with burn events").option("--token-id <ids>", "Filter by token IDs (comma-separated)").option("--page <number>", "Page number").option("--page-size <number>", "Items per page").action(async (opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await listBurns(client, {
+    tokenId: opts.tokenId,
+    page: opts.page,
+    pageSize: opts.pageSize
+  });
+  output(data, listColumns3, globalOpts.output || "table");
+});
+burnCommand.command("detail <tokenSlug>").description("Get burn events for a specific token").option("--start <date>", "Start date (YYYY-MM-DD)").option("--end <date>", "End date (YYYY-MM-DD)").action(async (tokenSlug, opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await getBurnDetail(client, tokenSlug, {
+    start: opts.start,
+    end: opts.end
+  });
+  const outputMode = globalOpts.output || "table";
+  if (outputMode === "json") {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(`Token: ${data.tokenName} (${data.tokenSymbol})`);
+    console.log(`Total Burned: ${data.totalBurnAmount.toLocaleString()}`);
+    console.log();
+    output(data.burns, detailColumns2, outputMode);
+  }
+});
+
+// src/commands/buyback.ts
+import { Command as Command6 } from "commander";
+
+// src/api/buyback.ts
+async function listBuybacks(client, params) {
+  return client.get("/v5/buyback/list", params);
+}
+async function getBuybackDetail(client, tokenSlug, params) {
+  return client.get(
+    `/v5/buyback/${encodeURIComponent(tokenSlug)}`,
+    params
+  );
+}
+
+// src/commands/buyback.ts
+var listColumns4 = [
+  { key: "tokenId", header: "ID" },
+  { key: "tokenName", header: "Name" },
+  { key: "tokenSymbol", header: "Symbol" },
+  { key: "totalBuybackAmount", header: "Total Buyback", align: "right" }
+];
+var detailColumns3 = [
+  { key: "buybackEventLabel", header: "Label" },
+  { key: "buybackType", header: "Type" },
+  { key: "buybackDate", header: "Date" },
+  { key: "tokenAmount", header: "Amount", align: "right" },
+  { key: "value", header: "Value", align: "right" },
+  { key: "spentAmount", header: "Spent", align: "right" },
+  { key: "spentUnit", header: "Unit" }
+];
+var buybackCommand = new Command6("buyback").description("Token buyback commands");
+buybackCommand.command("list").description("List all tokens with buyback events").option("--token-id <ids>", "Filter by token IDs (comma-separated)").option("--page <number>", "Page number").option("--page-size <number>", "Items per page").action(async (opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await listBuybacks(client, {
+    tokenId: opts.tokenId,
+    page: opts.page,
+    pageSize: opts.pageSize
+  });
+  output(data, listColumns4, globalOpts.output || "table");
+});
+buybackCommand.command("detail <tokenSlug>").description("Get buyback events for a specific token").option("--start <date>", "Start date (YYYY-MM-DD)").option("--end <date>", "End date (YYYY-MM-DD)").action(async (tokenSlug, opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await getBuybackDetail(client, tokenSlug, {
+    start: opts.start,
+    end: opts.end
+  });
+  const outputMode = globalOpts.output || "table";
+  if (outputMode === "json") {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(`Token: ${data.tokenName} (${data.tokenSymbol})`);
+    console.log(`Total Buyback: ${data.totalBuybackAmount.toLocaleString()}`);
+    console.log();
+    output(data.buybacks, detailColumns3, outputMode);
+  }
+});
+
+// src/commands/emission.ts
+import { Command as Command7 } from "commander";
+
+// src/api/emission.ts
+async function getDailyEmission(client, tokenSlug, params) {
+  return client.get(
+    `/v5/daily-emission/${encodeURIComponent(tokenSlug)}`,
+    params
+  );
+}
+async function getWeeklyEmission(client, tokenSlug, params) {
+  return client.get(
+    `/v5/emission/${encodeURIComponent(tokenSlug)}`,
+    params
+  );
+}
+
+// src/commands/emission.ts
+var columns3 = [
+  { key: "startDate", header: "Start" },
+  { key: "endDate", header: "End" },
+  { key: "tokenName", header: "Token" },
+  { key: "tokenSymbol", header: "Symbol" },
+  { key: "unlockAmount", header: "Unlock Amt", align: "right" },
+  { key: "unlockValue", header: "Unlock Val", align: "right" },
+  { key: "referencePrice", header: "Ref Price", align: "right" },
+  { key: "totalCumulativeUnlockedAmount", header: "Cumulative", align: "right" }
+];
+var emissionCommand = new Command7("emission").description("Token emission commands");
+emissionCommand.command("daily <tokenSlug>").description("Get daily emission breakdown for a token").option("--start <date>", "Start date (YYYY-MM-DD)").option("--end <date>", "End date (YYYY-MM-DD)").option("--standard-allocation <names>", "Filter by allocation (comma-separated)").option("--page <number>", "Page number").option("--page-size <number>", "Items per page").action(async (tokenSlug, opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await getDailyEmission(client, tokenSlug, {
+    start: opts.start,
+    end: opts.end,
+    standardAllocation: opts.standardAllocation,
+    page: opts.page,
+    pageSize: opts.pageSize
+  });
+  output(data, columns3, globalOpts.output || "table");
+});
+emissionCommand.command("weekly <tokenSlug>").description("Get weekly emission breakdown for a token").option("--start <date>", "Start date (YYYY-MM-DD)").option("--end <date>", "End date (YYYY-MM-DD)").option("--standard-allocation <names>", "Filter by allocation (comma-separated)").option("--page <number>", "Page number").option("--page-size <number>", "Items per page").action(async (tokenSlug, opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await getWeeklyEmission(client, tokenSlug, {
+    start: opts.start,
+    end: opts.end,
+    standardAllocation: opts.standardAllocation,
+    page: opts.page,
+    pageSize: opts.pageSize
+  });
+  output(data, columns3, globalOpts.output || "table");
+});
+
+// src/commands/allocation.ts
+import { Command as Command8 } from "commander";
+
+// src/api/allocation.ts
+async function getAllocation(client, tokenSlug) {
+  return client.get(
+    `/v5/allocations/${encodeURIComponent(tokenSlug)}`
+  );
+}
+
+// src/commands/allocation.ts
+var columns4 = [
+  { key: "allocationName", header: "Allocation" },
+  { key: "allocationType", header: "Type" },
+  { key: "standardAllocationName", header: "Std. Allocation" },
+  { key: "allocationAmount", header: "Amount", align: "right" },
+  { key: "allocationUnlockedAmount", header: "Unlocked", align: "right" },
+  { key: "allocationLockedAmount", header: "Locked", align: "right" },
+  { key: "trackedAllocationPercentage", header: "Tracked %", align: "right" }
+];
+var allocationCommand = new Command8("allocation").description("Get standard allocation data for a token").argument("<tokenSlug>", "Token slug").action(async (tokenSlug, _opts, cmd) => {
+  const globalOpts = cmd.optsWithGlobals();
+  const config = resolveConfig(globalOpts);
+  const client = new TokenomistClient(config.apiKey, config.baseUrl, {
+    noCache: config.noCache
+  });
+  const data = await getAllocation(client, tokenSlug);
+  const outputMode = globalOpts.output || "table";
+  if (outputMode === "json") {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(`Token: ${data.name} (${data.symbol})`);
+    console.log(`Max Supply: ${data.maxSupply?.toLocaleString() ?? "\u2014"}`);
+    console.log(`Total Unlocked: ${data.totalUnlockedAmount.toLocaleString()}`);
+    console.log(`Total Locked: ${data.totalLockedAmount.toLocaleString()}`);
+    console.log(`Last Updated: ${data.lastUpdatedDate}`);
+    console.log();
+    output(data.allocations, columns4, outputMode);
+  }
+});
+
+// src/commands/auth.ts
+import { Command as Command9 } from "commander";
+import { createInterface } from "readline";
+function readInput(prompt) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+var authCommand = new Command9("auth").description("Manage API key authentication");
+authCommand.command("login").description("Store your API key securely in ~/.tokenomist/config.json").option("--api-key <key>", "API key (will prompt if not provided)").action(async (opts) => {
+  let apiKey = opts.apiKey;
+  if (!apiKey) {
+    apiKey = await readInput("Enter your Tokenomist API key: ");
+  }
+  if (!apiKey) {
+    console.error("Error: API key cannot be empty.");
+    process.exit(1);
+  }
+  const config = loadConfigFile();
+  config.apiKey = apiKey;
+  saveConfigFile(config);
+  console.log(`API key saved to ${getConfigPath()}`);
+  console.log(`Key: ${maskApiKey(apiKey)}`);
+});
+authCommand.command("logout").description("Remove stored API key").action(() => {
+  const config = loadConfigFile();
+  if (!config.apiKey) {
+    console.log("No API key stored.");
+    return;
+  }
+  delete config.apiKey;
+  if (Object.keys(config).length === 0) {
+    deleteConfigFile();
+    console.log(`Removed ${getConfigPath()}`);
+  } else {
+    saveConfigFile(config);
+    console.log("API key removed from config.");
+  }
+});
+authCommand.command("status").description("Show current authentication status").action(() => {
+  const envKey = process.env.TOKENOMIST_API_KEY;
+  const config = loadConfigFile();
+  const fileKey = config.apiKey;
+  if (envKey) {
+    console.log(`Source:  TOKENOMIST_API_KEY env var`);
+    console.log(`Key:     ${maskApiKey(envKey)}`);
+  } else if (fileKey) {
+    console.log(`Source:  ${getConfigPath()}`);
+    console.log(`Key:     ${maskApiKey(fileKey)}`);
+  } else {
+    console.log("Not authenticated.");
+    console.log(`Run "tokenomist auth login" to store your API key.`);
+  }
+});
+
+// src/commands/schema.ts
+import { Command as Command10 } from "commander";
+
+// src/schema.json
+var schema_default = {
+  name: "tokenomist",
+  version: "0.1.0",
+  description: "CLI tool for the Tokenomist API",
+  globalOptions: {
+    "api-key": { flags: "-k, --api-key <key>", description: "API key (overrides env/config)" },
+    output: { flags: "-o, --output <format>", description: "Output format: table, json, csv", default: "table" },
+    "base-url": { flags: "--base-url <url>", description: "API base URL" },
+    "no-cache": { flags: "--no-cache", description: "Bypass response cache" }
+  },
+  commands: {
+    "token list": {
+      description: "List all tracked tokens with market data",
+      options: {
+        "token-id": { flags: "--token-id <ids>", description: "Filter by token IDs (comma-separated)" }
+      },
+      example: "tokenomist token list --output json"
+    },
+    "token search <query>": {
+      description: "Search for tokens by name, symbol, or slug",
+      arguments: { query: { required: true, description: "Search query string" } },
+      example: "tokenomist token search bitcoin --output json"
+    },
+    "unlock list": {
+      description: "List unlock events grouped by token",
+      options: {
+        "min-market-cap": { flags: "--min-market-cap <value>", description: "Minimum market cap" },
+        "min-released-percentage": { flags: "--min-released-percentage <value>", description: "Minimum released percentage" },
+        "min-unlock-date": { flags: "--min-unlock-date <date>", description: "Min unlock date (YYYY-MM-DD)" },
+        "max-unlock-date": { flags: "--max-unlock-date <date>", description: "Max unlock date (YYYY-MM-DD)" },
+        "min-total-unlock-amount": { flags: "--min-total-unlock-amount <value>", description: "Minimum total unlock amount" },
+        "min-value-to-market-cap": { flags: "--min-value-to-market-cap <value>", description: "Min value-to-market-cap ratio" },
+        "standard-allocation": { flags: "--standard-allocation <names>", description: "Filter by allocation (comma-separated)" },
+        page: { flags: "--page <number>", description: "Page number" },
+        "page-size": { flags: "--page-size <number>", description: "Items per page" }
+      },
+      example: "tokenomist unlock list --min-market-cap 1000000"
+    },
+    "unlock upcoming": {
+      description: "List next upcoming unlock event per token",
+      options: {
+        start: { flags: "--start <date>", description: "Start date (YYYY-MM-DD)" },
+        end: { flags: "--end <date>", description: "End date (YYYY-MM-DD)" },
+        "standard-allocation": { flags: "--standard-allocation <names>", description: "Filter by allocation (comma-separated)" },
+        "min-market-cap": { flags: "--min-market-cap <value>", description: "Minimum market cap" },
+        "min-released-percentage": { flags: "--min-released-percentage <value>", description: "Minimum released percentage" },
+        "min-total-unlock-amount": { flags: "--min-total-unlock-amount <value>", description: "Minimum total unlock amount" },
+        "min-value-to-market-cap": { flags: "--min-value-to-market-cap <value>", description: "Min value-to-market-cap ratio" },
+        page: { flags: "--page <number>", description: "Page number" },
+        "page-size": { flags: "--page-size <number>", description: "Items per page" }
+      },
+      example: "tokenomist unlock upcoming --output json"
+    },
+    "unlock events <tokenSlug>": {
+      description: "Get unlock events for a specific token",
+      arguments: { tokenSlug: { required: true, description: "Token slug (e.g. solana)" } },
+      options: {
+        start: { flags: "--start <date>", description: "Start date (YYYY-MM-DD)" },
+        end: { flags: "--end <date>", description: "End date (YYYY-MM-DD)" },
+        "standard-allocation": { flags: "--standard-allocation <names>", description: "Filter by allocation (comma-separated)" },
+        page: { flags: "--page <number>", description: "Page number" },
+        "page-size": { flags: "--page-size <number>", description: "Items per page" }
+      },
+      example: "tokenomist unlock events solana --start 2024-01-01 --end 2024-12-31"
+    },
+    "investor list": {
+      description: "List all investors",
+      options: {
+        "start-latest-funding-date": { flags: "--start-latest-funding-date <date>", description: "Start date filter for latest funding (YYYY-MM-DD)" },
+        "end-latest-funding-date": { flags: "--end-latest-funding-date <date>", description: "End date filter for latest funding (YYYY-MM-DD)" },
+        page: { flags: "--page <number>", description: "Page number" },
+        "page-size": { flags: "--page-size <number>", description: "Items per page" }
+      },
+      example: "tokenomist investor list --output json"
+    },
+    "investor detail <investorId>": {
+      description: "Get investor portfolio and funding rounds",
+      arguments: { investorId: { required: true, description: "Investor ID" } },
+      options: {
+        "is-lead-investor": { flags: "--is-lead-investor", description: "Filter to rounds where investor was lead" },
+        "funding-date-min": { flags: "--funding-date-min <date>", description: "Minimum funding date" },
+        "funding-date-max": { flags: "--funding-date-max <date>", description: "Maximum funding date" },
+        "raised-amount-min": { flags: "--raised-amount-min <amount>", description: "Minimum raised amount" },
+        "raised-amount-max": { flags: "--raised-amount-max <amount>", description: "Maximum raised amount" }
+      },
+      example: "tokenomist investor detail 123 --is-lead-investor"
+    },
+    "fundraising <tokenSlug>": {
+      description: "Get fundraising data for a token",
+      arguments: { tokenSlug: { required: true, description: "Token slug" } },
+      options: {
+        "funding-date-min": { flags: "--funding-date-min <date>", description: "Minimum funding date" },
+        "funding-date-max": { flags: "--funding-date-max <date>", description: "Maximum funding date" },
+        "raised-amount-min": { flags: "--raised-amount-min <amount>", description: "Minimum raised amount" },
+        "raised-amount-max": { flags: "--raised-amount-max <amount>", description: "Maximum raised amount" }
+      },
+      example: "tokenomist fundraising uniswap --output json"
+    },
+    "burn list": {
+      description: "List all tokens with burn data",
+      options: {
+        "token-id": { flags: "--token-id <ids>", description: "Filter by token IDs (comma-separated)" },
+        page: { flags: "--page <number>", description: "Page number" },
+        "page-size": { flags: "--page-size <number>", description: "Items per page" }
+      },
+      example: "tokenomist burn list --output json"
+    },
+    "burn detail <tokenSlug>": {
+      description: "Get burn events for a specific token",
+      arguments: { tokenSlug: { required: true, description: "Token slug" } },
+      options: {
+        start: { flags: "--start <date>", description: "Start date" },
+        end: { flags: "--end <date>", description: "End date" }
+      },
+      example: "tokenomist burn detail solana --start 2024-01-01"
+    },
+    "buyback list": {
+      description: "List all tokens with buyback data",
+      options: {
+        "token-id": { flags: "--token-id <ids>", description: "Filter by token IDs (comma-separated)" },
+        page: { flags: "--page <number>", description: "Page number" },
+        "page-size": { flags: "--page-size <number>", description: "Items per page" }
+      },
+      example: "tokenomist buyback list --output json"
+    },
+    "buyback detail <tokenSlug>": {
+      description: "Get buyback events for a specific token",
+      arguments: { tokenSlug: { required: true, description: "Token slug" } },
+      options: {
+        start: { flags: "--start <date>", description: "Start date" },
+        end: { flags: "--end <date>", description: "End date" }
+      },
+      example: "tokenomist buyback detail solana --output json"
+    },
+    "emission daily <tokenSlug>": {
+      description: "Get daily emission data for a token",
+      arguments: { tokenSlug: { required: true, description: "Token slug" } },
+      options: {
+        start: { flags: "--start <date>", description: "Start date" },
+        end: { flags: "--end <date>", description: "End date" },
+        "standard-allocation": { flags: "--standard-allocation <names>", description: "Filter by allocation (comma-separated)" },
+        page: { flags: "--page <number>", description: "Page number" },
+        "page-size": { flags: "--page-size <number>", description: "Items per page" }
+      },
+      example: "tokenomist emission daily arbitrum --start 2024-08-01 --end 2024-08-31"
+    },
+    "emission weekly <tokenSlug>": {
+      description: "Get weekly emission data for a token",
+      arguments: { tokenSlug: { required: true, description: "Token slug" } },
+      options: {
+        start: { flags: "--start <date>", description: "Start date" },
+        end: { flags: "--end <date>", description: "End date" },
+        "standard-allocation": { flags: "--standard-allocation <names>", description: "Filter by allocation (comma-separated)" },
+        page: { flags: "--page <number>", description: "Page number" },
+        "page-size": { flags: "--page-size <number>", description: "Items per page" }
+      },
+      example: "tokenomist emission weekly arbitrum --start 2024-01-01 --end 2024-06-30"
+    },
+    "allocation <tokenSlug>": {
+      description: "Get standard allocation distribution for a token",
+      arguments: { tokenSlug: { required: true, description: "Token slug" } },
+      example: "tokenomist allocation solana --output json"
+    },
+    "auth login": {
+      description: "Store API key",
+      options: {
+        "api-key": { flags: "--api-key <key>", description: "API key (prompts if not provided)" }
+      },
+      example: "tokenomist auth login"
+    },
+    "auth logout": {
+      description: "Remove stored API key",
+      example: "tokenomist auth logout"
+    },
+    "auth status": {
+      description: "Show current auth status",
+      example: "tokenomist auth status"
+    },
+    schema: {
+      description: "Print full command schema as JSON",
+      options: {
+        pretty: { flags: "--pretty", description: "Pretty-print with 2-space indent" }
+      },
+      example: "tokenomist schema --pretty"
+    }
+  }
+};
+
+// src/commands/schema.ts
+var schemaCommand = new Command10("schema").description("Print full command schema as JSON").option("--pretty", "Pretty-print with 2-space indent").action((opts) => {
+  const indent = opts.pretty ? 2 : void 0;
+  console.log(JSON.stringify(schema_default, null, indent));
+});
+
+// src/index.ts
+import { spawn } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { fileURLToPath } from "url";
+var ONE_DAY = 24 * 60 * 60 * 1e3;
+function showUpdateNotification() {
+  if (process.env.NO_UPDATE_NOTIFIER === "1" || process.env.CI === "1") return;
+  try {
+    const raw = readFileSync3(join3(homedir3(), ".tokenomist", "update-check.json"), "utf-8");
+    const data = JSON.parse(raw);
+    if (data.latest !== data.current && Date.now() - data.checkedAt < ONE_DAY) {
+      process.stderr.write(
+        `
+Update available: ${data.current} \u2192 ${data.latest}  (npm i -g @tokenomist-ai/tokenomist-cli)
+
+`
+      );
+    }
+  } catch {
+  }
+}
+function spawnUpdateCheck() {
+  if (process.env.NO_UPDATE_NOTIFIER === "1" || process.env.CI === "1") return;
+  try {
+    const script = fileURLToPath(new URL("./update-check.js", import.meta.url));
+    spawn("node", [script], { detached: true, stdio: "ignore" }).unref();
+  } catch {
+  }
+}
+var program = new Command11();
+program.name("tokenomist").description(
+  "CLI tool for the Tokenomist API \u2014 query token unlocks, emissions, fundraising, burns, and buybacks"
+).version("0.1.0").option("-k, --api-key <key>", "API key (overrides env/config)").option("-o, --output <format>", "Output format: table, json, csv", "table").option("--base-url <url>", "API base URL").option("--no-cache", "Bypass response cache");
+program.addCommand(tokenCommand);
+program.addCommand(unlockCommand);
+program.addCommand(investorCommand);
+program.addCommand(fundraisingCommand);
+program.addCommand(burnCommand);
+program.addCommand(buybackCommand);
+program.addCommand(emissionCommand);
+program.addCommand(allocationCommand);
+program.addCommand(authCommand);
+program.addCommand(schemaCommand);
+showUpdateNotification();
+program.parseAsync(process.argv).then(() => {
+  spawnUpdateCheck();
+}).catch((err) => {
+  if (err instanceof ApiError) {
+    if (err.retriesExhausted) {
+      if (err.detail) console.error(`Detail: ${err.detail}`);
+    } else {
+      console.error(`${err.code}: ${err.message}`);
+      if (err.detail) console.error(`Detail: ${err.detail}`);
+    }
+  } else {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  spawnUpdateCheck();
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map